GET List Payment Channel Country Rules
{{baseUrl}}/v1/paymentChannelRules
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/paymentChannelRules");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/paymentChannelRules")
require "http/client"

url = "{{baseUrl}}/v1/paymentChannelRules"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/paymentChannelRules"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/paymentChannelRules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/paymentChannelRules"

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

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

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

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

}
GET /baseUrl/v1/paymentChannelRules HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/paymentChannelRules")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/paymentChannelRules"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/paymentChannelRules")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/paymentChannelRules")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/paymentChannelRules');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/paymentChannelRules'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/paymentChannelRules';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/paymentChannelRules',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/paymentChannelRules")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/paymentChannelRules',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/paymentChannelRules'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/paymentChannelRules');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/paymentChannelRules'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/paymentChannelRules';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/paymentChannelRules"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/paymentChannelRules" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/paymentChannelRules",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/paymentChannelRules');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/paymentChannelRules');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/paymentChannelRules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/paymentChannelRules' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/paymentChannelRules' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/paymentChannelRules")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/paymentChannelRules"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/paymentChannelRules"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/paymentChannelRules")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/paymentChannelRules') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/paymentChannelRules";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/paymentChannelRules
http GET {{baseUrl}}/v1/paymentChannelRules
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/paymentChannelRules
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/paymentChannelRules")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "bank": [
    {
      "isoCountryCode": "US",
      "rules": [
        {
          "displayName": "Account Name",
          "displayOrder": 0,
          "element": "accountName",
          "maxLength": 50,
          "minLength": 5,
          "required": true,
          "validation": "^[0-9]{6,11}$"
        },
        {
          "displayName": "Account Name",
          "displayOrder": 0,
          "element": "accountName",
          "maxLength": 50,
          "minLength": 5,
          "required": true,
          "validation": "^[0-9]{6,11}$"
        }
      ]
    },
    {
      "isoCountryCode": "US",
      "rules": [
        {
          "displayName": "Account Name",
          "displayOrder": 0,
          "element": "accountName",
          "maxLength": 50,
          "minLength": 5,
          "required": true,
          "validation": "^[0-9]{6,11}$"
        },
        {
          "displayName": "Account Name",
          "displayOrder": 0,
          "element": "accountName",
          "maxLength": 50,
          "minLength": 5,
          "required": true,
          "validation": "^[0-9]{6,11}$"
        }
      ]
    }
  ]
}
GET List Supported Countries (GET)
{{baseUrl}}/v2/supportedCountries
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/supportedCountries");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/supportedCountries")
require "http/client"

url = "{{baseUrl}}/v2/supportedCountries"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/supportedCountries"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/supportedCountries");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/supportedCountries"

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

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

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

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

}
GET /baseUrl/v2/supportedCountries HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/supportedCountries")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/supportedCountries"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/supportedCountries")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/supportedCountries")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/supportedCountries');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/supportedCountries'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/supportedCountries';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/supportedCountries',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/supportedCountries")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/supportedCountries',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/supportedCountries'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/supportedCountries');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/supportedCountries'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/supportedCountries';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/supportedCountries"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/supportedCountries" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/supportedCountries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/supportedCountries');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/supportedCountries');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/supportedCountries');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/supportedCountries' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/supportedCountries' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/supportedCountries")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/supportedCountries"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/supportedCountries"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/supportedCountries")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/supportedCountries') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/supportedCountries";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/supportedCountries
http GET {{baseUrl}}/v2/supportedCountries
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/supportedCountries
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/supportedCountries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
GET List Supported Countries
{{baseUrl}}/v1/supportedCountries
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/supportedCountries");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/supportedCountries")
require "http/client"

url = "{{baseUrl}}/v1/supportedCountries"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/supportedCountries"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/supportedCountries");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/supportedCountries"

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

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

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

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

}
GET /baseUrl/v1/supportedCountries HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/supportedCountries")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/supportedCountries"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/supportedCountries")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/supportedCountries")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/supportedCountries');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/supportedCountries'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/supportedCountries';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/supportedCountries',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/supportedCountries")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/supportedCountries',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/supportedCountries'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/supportedCountries');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/supportedCountries'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/supportedCountries';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/supportedCountries"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/supportedCountries" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/supportedCountries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/supportedCountries');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/supportedCountries');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/supportedCountries');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/supportedCountries' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/supportedCountries' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/supportedCountries")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/supportedCountries"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/supportedCountries"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/supportedCountries")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/supportedCountries') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/supportedCountries";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/supportedCountries
http GET {{baseUrl}}/v1/supportedCountries
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/supportedCountries
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/supportedCountries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
GET List Supported Currencies
{{baseUrl}}/v2/currencies
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/currencies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/currencies")
require "http/client"

url = "{{baseUrl}}/v2/currencies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/currencies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/currencies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/currencies"

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

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

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

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

}
GET /baseUrl/v2/currencies HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/currencies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/currencies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/currencies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/currencies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/currencies');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/currencies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/currencies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/currencies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/currencies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/currencies',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/currencies'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/currencies');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/currencies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/currencies';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/currencies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/currencies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/currencies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/currencies');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/currencies');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/currencies');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/currencies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/currencies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/currencies")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/currencies"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/currencies"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/currencies")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/currencies') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/currencies";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/currencies
http GET {{baseUrl}}/v2/currencies
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/currencies
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/currencies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
POST Create Funding Request (POST)
{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest
QUERY PARAMS

sourceAccountId
BODY json

{
  "amount": 0,
  "fundingAccountId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest" {:content-type :json
                                                                                              :form-params {:amount 800828191
                                                                                                            :fundingAccountId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"}})
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"),
    Content = new StringContent("{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"

	payload := strings.NewReader("{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")

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

	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))

}
POST /baseUrl/v3/sourceAccounts/:sourceAccountId/fundingRequest HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .asString();
const data = JSON.stringify({
  amount: 800828191,
  fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  data: {amount: 800828191, fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"fundingAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 800828191,\n  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({amount: 800828191, fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  body: {amount: 800828191, fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: 800828191,
  fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  data: {amount: 800828191, fundingAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"fundingAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @800828191,
                              @"fundingAccountId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => 800828191,
    'fundingAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest', [
  'body' => '{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 800828191,
  'fundingAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'amount' => 800828191,
  'fundingAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));
$request->setRequestUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/sourceAccounts/:sourceAccountId/fundingRequest", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"

payload = {
    "amount": 800828191,
    "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest"

payload <- "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/sourceAccounts/:sourceAccountId/fundingRequest') do |req|
  req.body = "{\n  \"amount\": 800828191,\n  \"fundingAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest";

    let payload = json!({
        "amount": 800828191,
        "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest \
  --header 'content-type: application/json' \
  --data '{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
echo '{
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}' |  \
  http POST {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 800828191,\n  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}' \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": 800828191,
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/fundingRequest")! 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()
POST Create Funding Request
{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest
QUERY PARAMS

sourceAccountId
BODY json

{
  "amount": 0
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": 800828191\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest" {:content-type :json
                                                                                              :form-params {:amount 800828191}})
require "http/client"

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": 800828191\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"),
    Content = new StringContent("{\n  \"amount\": 800828191\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": 800828191\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"

	payload := strings.NewReader("{\n  \"amount\": 800828191\n}")

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

	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))

}
POST /baseUrl/v2/sourceAccounts/:sourceAccountId/fundingRequest HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 25

{
  "amount": 800828191
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 800828191\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": 800828191\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 800828191\n}")
  .asString();
const data = JSON.stringify({
  amount: 800828191
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  data: {amount: 800828191}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 800828191\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({amount: 800828191}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  body: {amount: 800828191},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: 800828191
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest',
  headers: {'content-type': 'application/json'},
  data: {amount: 800828191}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @800828191 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 800828191\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => 800828191
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest', [
  'body' => '{
  "amount": 800828191
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 800828191
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'amount' => 800828191
]));
$request->setRequestUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": 800828191\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/sourceAccounts/:sourceAccountId/fundingRequest", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"

payload = { "amount": 800828191 }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest"

payload <- "{\n  \"amount\": 800828191\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": 800828191\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/sourceAccounts/:sourceAccountId/fundingRequest') do |req|
  req.body = "{\n  \"amount\": 800828191\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest";

    let payload = json!({"amount": 800828191});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest \
  --header 'content-type: application/json' \
  --data '{
  "amount": 800828191
}'
echo '{
  "amount": 800828191
}' |  \
  http POST {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 800828191\n}' \
  --output-document \
  - {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["amount": 800828191] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/fundingRequest")! 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()
GET Get Funding Account
{{baseUrl}}/v2/fundingAccounts/:fundingAccountId
QUERY PARAMS

fundingAccountId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")
require "http/client"

url = "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"

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

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

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

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

}
GET /baseUrl/v2/fundingAccounts/:fundingAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/fundingAccounts/:fundingAccountId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/fundingAccounts/:fundingAccountId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/fundingAccounts/:fundingAccountId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/fundingAccounts/:fundingAccountId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/fundingAccounts/:fundingAccountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/fundingAccounts/:fundingAccountId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/fundingAccounts/:fundingAccountId
http GET {{baseUrl}}/v2/fundingAccounts/:fundingAccountId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/fundingAccounts/:fundingAccountId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/fundingAccounts/:fundingAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "accountName": "Payor Corp",
  "accountNumber": "7001001234",
  "archived": true,
  "country": "US",
  "currency": "USD",
  "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "name": "My Funding Account",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "routingNumber": 12345678,
  "type": "FBO"
}
GET Get Funding Accounts
{{baseUrl}}/v2/fundingAccounts
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/fundingAccounts");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/fundingAccounts")
require "http/client"

url = "{{baseUrl}}/v2/fundingAccounts"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/fundingAccounts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/fundingAccounts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/fundingAccounts"

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

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

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

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

}
GET /baseUrl/v2/fundingAccounts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/fundingAccounts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/fundingAccounts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/fundingAccounts")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/fundingAccounts');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/fundingAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/fundingAccounts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/fundingAccounts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/fundingAccounts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/fundingAccounts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/fundingAccounts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/fundingAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/fundingAccounts';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/fundingAccounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/fundingAccounts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/fundingAccounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/fundingAccounts');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/fundingAccounts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/fundingAccounts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/fundingAccounts' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/fundingAccounts' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/fundingAccounts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/fundingAccounts"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/fundingAccounts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/fundingAccounts")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/fundingAccounts') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/fundingAccounts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/fundingAccounts
http GET {{baseUrl}}/v2/fundingAccounts
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/fundingAccounts
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/fundingAccounts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountName": "Payor Corp",
      "accountNumber": "7001001234",
      "archived": true,
      "country": "US",
      "currency": "USD",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "My Funding Account",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "routingNumber": 12345678,
      "type": "FBO"
    },
    {
      "accountName": "Payor Corp",
      "accountNumber": "7001001234",
      "archived": true,
      "country": "US",
      "currency": "USD",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "My Funding Account",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "routingNumber": 12345678,
      "type": "FBO"
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v1/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v1/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 1,
    "page": 1,
    "pageSize": 25,
    "totalElements": 1,
    "totalPages": 2
  }
}
GET Get Funding Audit Delta
{{baseUrl}}/v1/deltas/fundings
QUERY PARAMS

payorId
updatedSince
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/deltas/fundings" {:query-params {:payorId ""
                                                                             :updatedSince ""}})
require "http/client"

url = "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince="

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

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

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

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

}
GET /baseUrl/v1/deltas/fundings?payorId=&updatedSince= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/fundings',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deltas/fundings?payorId=&updatedSince=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/fundings',
  qs: {payorId: '', updatedSince: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/deltas/fundings');

req.query({
  payorId: '',
  updatedSince: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/fundings',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/deltas/fundings');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => '',
  'updatedSince' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/deltas/fundings');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => '',
  'updatedSince' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/deltas/fundings?payorId=&updatedSince=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/deltas/fundings"

querystring = {"payorId":"","updatedSince":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/deltas/fundings"

queryString <- list(
  payorId = "",
  updatedSince = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/deltas/fundings') do |req|
  req.params['payorId'] = ''
  req.params['updatedSince'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deltas/fundings";

    let querystring = [
        ("payorId", ""),
        ("updatedSince", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince='
http GET '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deltas/fundings?payorId=&updatedSince=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "amount": 2,
      "currency": "USD",
      "fundingId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "status": "status"
    },
    {
      "amount": 2,
      "currency": "USD",
      "fundingId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "status": "status"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
GET Get Funding
{{baseUrl}}/v1/fundings/:fundingId
QUERY PARAMS

fundingId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/fundings/:fundingId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/fundings/:fundingId")
require "http/client"

url = "{{baseUrl}}/v1/fundings/:fundingId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/fundings/:fundingId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/fundings/:fundingId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/fundings/:fundingId"

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

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

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

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

}
GET /baseUrl/v1/fundings/:fundingId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/fundings/:fundingId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/fundings/:fundingId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/fundings/:fundingId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/fundings/:fundingId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/fundings/:fundingId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/fundings/:fundingId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/fundings/:fundingId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/fundings/:fundingId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/fundings/:fundingId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/fundings/:fundingId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/fundings/:fundingId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/fundings/:fundingId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/fundings/:fundingId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/fundings/:fundingId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/fundings/:fundingId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/fundings/:fundingId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/fundings/:fundingId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/fundings/:fundingId');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/fundings/:fundingId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/fundings/:fundingId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/fundings/:fundingId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/fundings/:fundingId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/fundings/:fundingId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/fundings/:fundingId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/fundings/:fundingId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/fundings/:fundingId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/fundings/:fundingId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/fundings/:fundingId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/fundings/:fundingId
http GET {{baseUrl}}/v1/fundings/:fundingId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/fundings/:fundingId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/fundings/:fundingId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "allocationDate": "2000-01-23T04:56:07.000+00:00",
  "allocationType": "allocationType",
  "amount": 0,
  "currency": "USD",
  "detectedFundingRef": "detectedFundingRef",
  "fundingAccountType": "FBO",
  "fundingId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "hiddenDate": "2000-01-23T04:56:07.000+00:00",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "physicalAccountName": "physicalAccountName",
  "reason": "reason",
  "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "status": "ALLOCATED",
  "text": "text"
}
POST Create Funding Account
{{baseUrl}}/v2/fundingAccounts
BODY json

{
  "accountName": "",
  "accountNumber": "",
  "currency": "",
  "name": "",
  "payorId": "",
  "routingNumber": "",
  "type": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/fundingAccounts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/fundingAccounts" {:content-type :json
                                                               :form-params {:accountName "My Account Name"
                                                                             :accountNumber 1231231234556
                                                                             :name "My FBO Account"
                                                                             :payorId "ee53e01d-c078-43fd-abd4-47e92f4a06cf"
                                                                             :routingNumber 123456789
                                                                             :type "FBO"}})
require "http/client"

url = "{{baseUrl}}/v2/fundingAccounts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/fundingAccounts"),
    Content = new StringContent("{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/fundingAccounts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/fundingAccounts"

	payload := strings.NewReader("{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}")

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

	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))

}
POST /baseUrl/v2/fundingAccounts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 200

{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/fundingAccounts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/fundingAccounts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/fundingAccounts")
  .header("content-type", "application/json")
  .body("{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}")
  .asString();
const data = JSON.stringify({
  accountName: 'My Account Name',
  accountNumber: 1231231234556,
  name: 'My FBO Account',
  payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
  routingNumber: 123456789,
  type: 'FBO'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/fundingAccounts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/fundingAccounts',
  headers: {'content-type': 'application/json'},
  data: {
    accountName: 'My Account Name',
    accountNumber: 1231231234556,
    name: 'My FBO Account',
    payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
    routingNumber: 123456789,
    type: 'FBO'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/fundingAccounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accountName":"My Account Name","accountNumber":1231231234556,"name":"My FBO Account","payorId":"ee53e01d-c078-43fd-abd4-47e92f4a06cf","routingNumber":123456789,"type":"FBO"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/fundingAccounts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountName": "My Account Name",\n  "accountNumber": 1231231234556,\n  "name": "My FBO Account",\n  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",\n  "routingNumber": 123456789,\n  "type": "FBO"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/fundingAccounts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/fundingAccounts',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  accountName: 'My Account Name',
  accountNumber: 1231231234556,
  name: 'My FBO Account',
  payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
  routingNumber: 123456789,
  type: 'FBO'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/fundingAccounts',
  headers: {'content-type': 'application/json'},
  body: {
    accountName: 'My Account Name',
    accountNumber: 1231231234556,
    name: 'My FBO Account',
    payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
    routingNumber: 123456789,
    type: 'FBO'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/fundingAccounts');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  accountName: 'My Account Name',
  accountNumber: 1231231234556,
  name: 'My FBO Account',
  payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
  routingNumber: 123456789,
  type: 'FBO'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/fundingAccounts',
  headers: {'content-type': 'application/json'},
  data: {
    accountName: 'My Account Name',
    accountNumber: 1231231234556,
    name: 'My FBO Account',
    payorId: 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
    routingNumber: 123456789,
    type: 'FBO'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/fundingAccounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accountName":"My Account Name","accountNumber":1231231234556,"name":"My FBO Account","payorId":"ee53e01d-c078-43fd-abd4-47e92f4a06cf","routingNumber":123456789,"type":"FBO"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"accountName": @"My Account Name",
                              @"accountNumber": @1231231234556,
                              @"name": @"My FBO Account",
                              @"payorId": @"ee53e01d-c078-43fd-abd4-47e92f4a06cf",
                              @"routingNumber": @123456789,
                              @"type": @"FBO" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/fundingAccounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/fundingAccounts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/fundingAccounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'accountName' => 'My Account Name',
    'accountNumber' => 1231231234556,
    'name' => 'My FBO Account',
    'payorId' => 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
    'routingNumber' => 123456789,
    'type' => 'FBO'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/fundingAccounts', [
  'body' => '{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/fundingAccounts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountName' => 'My Account Name',
  'accountNumber' => 1231231234556,
  'name' => 'My FBO Account',
  'payorId' => 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
  'routingNumber' => 123456789,
  'type' => 'FBO'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'accountName' => 'My Account Name',
  'accountNumber' => 1231231234556,
  'name' => 'My FBO Account',
  'payorId' => 'ee53e01d-c078-43fd-abd4-47e92f4a06cf',
  'routingNumber' => 123456789,
  'type' => 'FBO'
]));
$request->setRequestUrl('{{baseUrl}}/v2/fundingAccounts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/fundingAccounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/fundingAccounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/fundingAccounts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/fundingAccounts"

payload = {
    "accountName": "My Account Name",
    "accountNumber": 1231231234556,
    "name": "My FBO Account",
    "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
    "routingNumber": 123456789,
    "type": "FBO"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/fundingAccounts"

payload <- "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/fundingAccounts")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/fundingAccounts') do |req|
  req.body = "{\n  \"accountName\": \"My Account Name\",\n  \"accountNumber\": 1231231234556,\n  \"name\": \"My FBO Account\",\n  \"payorId\": \"ee53e01d-c078-43fd-abd4-47e92f4a06cf\",\n  \"routingNumber\": 123456789,\n  \"type\": \"FBO\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/fundingAccounts";

    let payload = json!({
        "accountName": "My Account Name",
        "accountNumber": 1231231234556,
        "name": "My FBO Account",
        "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
        "routingNumber": 123456789,
        "type": "FBO"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/fundingAccounts \
  --header 'content-type: application/json' \
  --data '{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}'
echo '{
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
}' |  \
  http POST {{baseUrl}}/v2/fundingAccounts \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountName": "My Account Name",\n  "accountNumber": 1231231234556,\n  "name": "My FBO Account",\n  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",\n  "routingNumber": 123456789,\n  "type": "FBO"\n}' \
  --output-document \
  - {{baseUrl}}/v2/fundingAccounts
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "accountName": "My Account Name",
  "accountNumber": 1231231234556,
  "name": "My FBO Account",
  "payorId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "routingNumber": 123456789,
  "type": "FBO"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/fundingAccounts")! 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()
DELETE Delete a source account by ID
{{baseUrl}}/v3/sourceAccounts/:sourceAccountId
QUERY PARAMS

sourceAccountId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

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

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

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

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

}
DELETE /baseUrl/v3/sourceAccounts/:sourceAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts/:sourceAccountId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v3/sourceAccounts/:sourceAccountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v3/sourceAccounts/:sourceAccountId') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
http DELETE {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
POST Authentication endpoint
{{baseUrl}}/v1/authenticate
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/authenticate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/authenticate")
require "http/client"

url = "{{baseUrl}}/v1/authenticate"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/authenticate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/authenticate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/authenticate"

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

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

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

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

}
POST /baseUrl/v1/authenticate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/authenticate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/authenticate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/authenticate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/authenticate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/authenticate');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/authenticate'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/authenticate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/authenticate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/authenticate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/authenticate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/authenticate'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/authenticate');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v1/authenticate'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/authenticate';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/authenticate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/authenticate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/authenticate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/authenticate');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/authenticate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/authenticate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/authenticate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/authenticate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/authenticate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/authenticate"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/authenticate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/authenticate")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/authenticate') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/authenticate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/authenticate
http POST {{baseUrl}}/v1/authenticate
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/authenticate
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/authenticate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "access_token": "IwOGYzYTlmM2YxOTQ5MGE3YmNmMDFkNTVk",
  "entityIds": [
    "entityIds",
    "entityIds"
  ],
  "expires_in": 1799,
  "refresh_token": "IwOGYzYTlmM2YxOTQ5MGE3YmNmMDFkNTVk",
  "scope": "example_scope",
  "token_type": "bearer"
}
POST Logout
{{baseUrl}}/v1/logout
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/logout");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/logout")
require "http/client"

url = "{{baseUrl}}/v1/logout"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/logout"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/logout");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/logout"

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

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

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

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

}
POST /baseUrl/v1/logout HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/logout")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/logout"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/logout")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/logout")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/logout');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/logout'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/logout';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/logout',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/logout")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/logout',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/logout'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/logout');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v1/logout'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/logout';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/logout"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/logout" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/logout",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/logout');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/logout');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/logout');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/logout' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/logout' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/logout")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/logout"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/logout"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/logout")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/logout') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/logout";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/logout
http POST {{baseUrl}}/v1/logout
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/logout
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/logout")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
POST Reset password
{{baseUrl}}/v1/password/reset
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/password/reset");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/password/reset")
require "http/client"

url = "{{baseUrl}}/v1/password/reset"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/password/reset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/password/reset");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/password/reset"

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

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

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

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

}
POST /baseUrl/v1/password/reset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/password/reset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/password/reset"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/password/reset")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/password/reset")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/password/reset');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/password/reset'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/password/reset';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/password/reset',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/password/reset")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/password/reset',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/password/reset'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/password/reset');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v1/password/reset'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/password/reset';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/password/reset"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/password/reset" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/password/reset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/password/reset');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/password/reset');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/password/reset');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/password/reset' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/password/reset' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/password/reset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/password/reset"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/password/reset"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/password/reset")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/password/reset') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/password/reset";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/password/reset
http POST {{baseUrl}}/v1/password/reset
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/password/reset
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/password/reset")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
POST validate
{{baseUrl}}/v1/validate
BODY json

{
  "otp": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/validate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"otp\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/validate" {:content-type :json
                                                        :form-params {:otp ""}})
require "http/client"

url = "{{baseUrl}}/v1/validate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"otp\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/validate"),
    Content = new StringContent("{\n  \"otp\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/validate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"otp\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/validate"

	payload := strings.NewReader("{\n  \"otp\": \"\"\n}")

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

	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))

}
POST /baseUrl/v1/validate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "otp": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/validate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"otp\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/validate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"otp\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"otp\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/validate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/validate")
  .header("content-type", "application/json")
  .body("{\n  \"otp\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  otp: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/validate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/validate',
  headers: {'content-type': 'application/json'},
  data: {otp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"otp":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/validate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "otp": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"otp\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/validate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/validate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({otp: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/validate',
  headers: {'content-type': 'application/json'},
  body: {otp: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/validate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  otp: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/validate',
  headers: {'content-type': 'application/json'},
  data: {otp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"otp":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"otp": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/validate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/validate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"otp\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/validate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'otp' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/validate', [
  'body' => '{
  "otp": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/validate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'otp' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'otp' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/validate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "otp": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "otp": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"otp\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/validate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/validate"

payload = { "otp": "" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/validate"

payload <- "{\n  \"otp\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/validate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"otp\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/validate') do |req|
  req.body = "{\n  \"otp\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/validate";

    let payload = json!({"otp": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/validate \
  --header 'content-type: application/json' \
  --data '{
  "otp": ""
}'
echo '{
  "otp": ""
}' |  \
  http POST {{baseUrl}}/v1/validate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "otp": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/validate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["otp": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/validate")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "access_token": "9b58410b-e1b7-4f90-bebb-7e09c5427020",
  "entityIds": [
    "ed89eaa0-4450-4916-a4ff-62a328d60bd6"
  ],
  "expires_in": 1800,
  "refresh_token": "c3d0f771-0997-4814-84e3-09690208545a",
  "scope": "https://api.velopayments.com/scopes/auth/users",
  "token_type": "bearer",
  "user_info": {
    "mfa_details": {
      "mfa_type": "TOTP",
      "verified": true
    },
    "userType": "PAYOR",
    "user_id": "39976ee5-dc4c-4b21-a966-a04fa71ef9e1"
  }
}
GET Get Payee Invitation Status (GET)
{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")
require "http/client"

url = "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"

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

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

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

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

}
GET /baseUrl/v4/payees/payors/:payorId/invitationStatus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/payors/:payorId/invitationStatus',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payees/payors/:payorId/invitationStatus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payees/payors/:payorId/invitationStatus') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/payees/payors/:payorId/invitationStatus
http GET {{baseUrl}}/v4/payees/payors/:payorId/invitationStatus
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/payees/payors/:payorId/invitationStatus
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/payors/:payorId/invitationStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
      "invitationStatus": "invitationStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9"
    },
    {
      "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
      "invitationStatus": "invitationStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
GET Get Payee Invitation Status
{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")
require "http/client"

url = "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"

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

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

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

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

}
GET /baseUrl/v3/payees/payors/:payorId/invitationStatus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/payors/:payorId/invitationStatus',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payees/payors/:payorId/invitationStatus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payees/payors/:payorId/invitationStatus') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/payees/payors/:payorId/invitationStatus
http GET {{baseUrl}}/v3/payees/payors/:payorId/invitationStatus
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/payees/payors/:payorId/invitationStatus
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/payors/:payorId/invitationStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
      "invitationStatus": "invitationStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9"
    },
    {
      "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
      "invitationStatus": "invitationStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
POST Initiate Payee Creation (POST)
{{baseUrl}}/v4/payees
BODY json

{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v4/payees" {:content-type :json
                                                      :form-params {:payees [{:address {:city ""
                                                                                        :country ""
                                                                                        :countyOrProvince ""
                                                                                        :line1 ""
                                                                                        :line2 ""
                                                                                        :line3 ""
                                                                                        :line4 ""
                                                                                        :zipOrPostcode ""}
                                                                              :challenge {:description ""
                                                                                          :value ""}
                                                                              :company {:name ""
                                                                                        :operatingName ""
                                                                                        :taxId ""}
                                                                              :email ""
                                                                              :individual {:dateOfBirth ""
                                                                                           :name ""
                                                                                           :nationalIdentification ""}
                                                                              :language ""
                                                                              :paymentChannel {:accountName ""
                                                                                               :accountNumber ""
                                                                                               :countryCode ""
                                                                                               :currency ""
                                                                                               :iban ""
                                                                                               :paymentChannelName ""
                                                                                               :routingNumber ""}
                                                                              :remoteId ""
                                                                              :type ""}]
                                                                    :payorId ""}})
require "http/client"

url = "{{baseUrl}}/v4/payees"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v4/payees"),
    Content = new StringContent("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees"

	payload := strings.NewReader("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")

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

	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))

}
POST /baseUrl/v4/payees HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 858

{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v4/payees")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v4/payees")
  .header("content-type", "application/json")
  .body("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {
        description: '',
        value: ''
      },
      company: {
        name: '',
        operatingName: '',
        taxId: ''
      },
      email: '',
      individual: {
        dateOfBirth: '',
        name: '',
        nationalIdentification: ''
      },
      language: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v4/payees');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees',
  headers: {'content-type': 'application/json'},
  data: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payees":[{"address":{"city":"","country":"","countyOrProvince":"","line1":"","line2":"","line3":"","line4":"","zipOrPostcode":""},"challenge":{"description":"","value":""},"company":{"name":"","operatingName":"","taxId":""},"email":"","individual":{"dateOfBirth":"","name":"","nationalIdentification":""},"language":"","paymentChannel":{"accountName":"","accountNumber":"","countryCode":"","currency":"","iban":"","paymentChannelName":"","routingNumber":""},"remoteId":"","type":""}],"payorId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payees": [\n    {\n      "address": {\n        "city": "",\n        "country": "",\n        "countyOrProvince": "",\n        "line1": "",\n        "line2": "",\n        "line3": "",\n        "line4": "",\n        "zipOrPostcode": ""\n      },\n      "challenge": {\n        "description": "",\n        "value": ""\n      },\n      "company": {\n        "name": "",\n        "operatingName": "",\n        "taxId": ""\n      },\n      "email": "",\n      "individual": {\n        "dateOfBirth": "",\n        "name": "",\n        "nationalIdentification": ""\n      },\n      "language": "",\n      "paymentChannel": {\n        "accountName": "",\n        "accountNumber": "",\n        "countryCode": "",\n        "currency": "",\n        "iban": "",\n        "paymentChannelName": "",\n        "routingNumber": ""\n      },\n      "remoteId": "",\n      "type": ""\n    }\n  ],\n  "payorId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {description: '', value: ''},
      company: {name: '', operatingName: '', taxId: ''},
      email: '',
      individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
      language: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees',
  headers: {'content-type': 'application/json'},
  body: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v4/payees');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {
        description: '',
        value: ''
      },
      company: {
        name: '',
        operatingName: '',
        taxId: ''
      },
      email: '',
      individual: {
        dateOfBirth: '',
        name: '',
        nationalIdentification: ''
      },
      language: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees',
  headers: {'content-type': 'application/json'},
  data: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payees":[{"address":{"city":"","country":"","countyOrProvince":"","line1":"","line2":"","line3":"","line4":"","zipOrPostcode":""},"challenge":{"description":"","value":""},"company":{"name":"","operatingName":"","taxId":""},"email":"","individual":{"dateOfBirth":"","name":"","nationalIdentification":""},"language":"","paymentChannel":{"accountName":"","accountNumber":"","countryCode":"","currency":"","iban":"","paymentChannelName":"","routingNumber":""},"remoteId":"","type":""}],"payorId":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payees": @[ @{ @"address": @{ @"city": @"", @"country": @"", @"countyOrProvince": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"line4": @"", @"zipOrPostcode": @"" }, @"challenge": @{ @"description": @"", @"value": @"" }, @"company": @{ @"name": @"", @"operatingName": @"", @"taxId": @"" }, @"email": @"", @"individual": @{ @"dateOfBirth": @"", @"name": @"", @"nationalIdentification": @"" }, @"language": @"", @"paymentChannel": @{ @"accountName": @"", @"accountNumber": @"", @"countryCode": @"", @"currency": @"", @"iban": @"", @"paymentChannelName": @"", @"routingNumber": @"" }, @"remoteId": @"", @"type": @"" } ],
                              @"payorId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payees' => [
        [
                'address' => [
                                'city' => '',
                                'country' => '',
                                'countyOrProvince' => '',
                                'line1' => '',
                                'line2' => '',
                                'line3' => '',
                                'line4' => '',
                                'zipOrPostcode' => ''
                ],
                'challenge' => [
                                'description' => '',
                                'value' => ''
                ],
                'company' => [
                                'name' => '',
                                'operatingName' => '',
                                'taxId' => ''
                ],
                'email' => '',
                'individual' => [
                                'dateOfBirth' => '',
                                'name' => '',
                                'nationalIdentification' => ''
                ],
                'language' => '',
                'paymentChannel' => [
                                'accountName' => '',
                                'accountNumber' => '',
                                'countryCode' => '',
                                'currency' => '',
                                'iban' => '',
                                'paymentChannelName' => '',
                                'routingNumber' => ''
                ],
                'remoteId' => '',
                'type' => ''
        ]
    ],
    'payorId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v4/payees', [
  'body' => '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payees' => [
    [
        'address' => [
                'city' => '',
                'country' => '',
                'countyOrProvince' => '',
                'line1' => '',
                'line2' => '',
                'line3' => '',
                'line4' => '',
                'zipOrPostcode' => ''
        ],
        'challenge' => [
                'description' => '',
                'value' => ''
        ],
        'company' => [
                'name' => '',
                'operatingName' => '',
                'taxId' => ''
        ],
        'email' => '',
        'individual' => [
                'dateOfBirth' => '',
                'name' => '',
                'nationalIdentification' => ''
        ],
        'language' => '',
        'paymentChannel' => [
                'accountName' => '',
                'accountNumber' => '',
                'countryCode' => '',
                'currency' => '',
                'iban' => '',
                'paymentChannelName' => '',
                'routingNumber' => ''
        ],
        'remoteId' => '',
        'type' => ''
    ]
  ],
  'payorId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payees' => [
    [
        'address' => [
                'city' => '',
                'country' => '',
                'countyOrProvince' => '',
                'line1' => '',
                'line2' => '',
                'line3' => '',
                'line4' => '',
                'zipOrPostcode' => ''
        ],
        'challenge' => [
                'description' => '',
                'value' => ''
        ],
        'company' => [
                'name' => '',
                'operatingName' => '',
                'taxId' => ''
        ],
        'email' => '',
        'individual' => [
                'dateOfBirth' => '',
                'name' => '',
                'nationalIdentification' => ''
        ],
        'language' => '',
        'paymentChannel' => [
                'accountName' => '',
                'accountNumber' => '',
                'countryCode' => '',
                'currency' => '',
                'iban' => '',
                'paymentChannelName' => '',
                'routingNumber' => ''
        ],
        'remoteId' => '',
        'type' => ''
    ]
  ],
  'payorId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v4/payees');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v4/payees", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees"

payload = {
    "payees": [
        {
            "address": {
                "city": "",
                "country": "",
                "countyOrProvince": "",
                "line1": "",
                "line2": "",
                "line3": "",
                "line4": "",
                "zipOrPostcode": ""
            },
            "challenge": {
                "description": "",
                "value": ""
            },
            "company": {
                "name": "",
                "operatingName": "",
                "taxId": ""
            },
            "email": "",
            "individual": {
                "dateOfBirth": "",
                "name": "",
                "nationalIdentification": ""
            },
            "language": "",
            "paymentChannel": {
                "accountName": "",
                "accountNumber": "",
                "countryCode": "",
                "currency": "",
                "iban": "",
                "paymentChannelName": "",
                "routingNumber": ""
            },
            "remoteId": "",
            "type": ""
        }
    ],
    "payorId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees"

payload <- "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v4/payees') do |req|
  req.body = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees";

    let payload = json!({
        "payees": (
            json!({
                "address": json!({
                    "city": "",
                    "country": "",
                    "countyOrProvince": "",
                    "line1": "",
                    "line2": "",
                    "line3": "",
                    "line4": "",
                    "zipOrPostcode": ""
                }),
                "challenge": json!({
                    "description": "",
                    "value": ""
                }),
                "company": json!({
                    "name": "",
                    "operatingName": "",
                    "taxId": ""
                }),
                "email": "",
                "individual": json!({
                    "dateOfBirth": "",
                    "name": "",
                    "nationalIdentification": ""
                }),
                "language": "",
                "paymentChannel": json!({
                    "accountName": "",
                    "accountNumber": "",
                    "countryCode": "",
                    "currency": "",
                    "iban": "",
                    "paymentChannelName": "",
                    "routingNumber": ""
                }),
                "remoteId": "",
                "type": ""
            })
        ),
        "payorId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v4/payees \
  --header 'content-type: application/json' \
  --data '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
echo '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}' |  \
  http POST {{baseUrl}}/v4/payees \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payees": [\n    {\n      "address": {\n        "city": "",\n        "country": "",\n        "countyOrProvince": "",\n        "line1": "",\n        "line2": "",\n        "line3": "",\n        "line4": "",\n        "zipOrPostcode": ""\n      },\n      "challenge": {\n        "description": "",\n        "value": ""\n      },\n      "company": {\n        "name": "",\n        "operatingName": "",\n        "taxId": ""\n      },\n      "email": "",\n      "individual": {\n        "dateOfBirth": "",\n        "name": "",\n        "nationalIdentification": ""\n      },\n      "language": "",\n      "paymentChannel": {\n        "accountName": "",\n        "accountNumber": "",\n        "countryCode": "",\n        "currency": "",\n        "iban": "",\n        "paymentChannelName": "",\n        "routingNumber": ""\n      },\n      "remoteId": "",\n      "type": ""\n    }\n  ],\n  "payorId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v4/payees
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payees": [
    [
      "address": [
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      ],
      "challenge": [
        "description": "",
        "value": ""
      ],
      "company": [
        "name": "",
        "operatingName": "",
        "taxId": ""
      ],
      "email": "",
      "individual": [
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      ],
      "language": "",
      "paymentChannel": [
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      ],
      "remoteId": "",
      "type": ""
    ]
  ],
  "payorId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "batchId": "cb6ff8c6-85e9-45a6-b7d9-d05305db67f3",
  "rejectedCsvRows": [
    {
      "lineNumber": 3,
      "message": "rejected message 1",
      "rejectedContent": "unable,to,process,csv,line"
    },
    {
      "lineNumber": 3,
      "message": "rejected message 1",
      "rejectedContent": "unable,to,process,csv,line"
    }
  ]
}
POST Initiate Payee Creation
{{baseUrl}}/v3/payees
BODY json

{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payees" {:content-type :json
                                                      :form-params {:payees [{:address {:city ""
                                                                                        :country ""
                                                                                        :countyOrProvince ""
                                                                                        :line1 ""
                                                                                        :line2 ""
                                                                                        :line3 ""
                                                                                        :line4 ""
                                                                                        :zipOrPostcode ""}
                                                                              :challenge {:description ""
                                                                                          :value ""}
                                                                              :company {:name ""
                                                                                        :operatingName ""
                                                                                        :taxId ""}
                                                                              :email ""
                                                                              :individual {:dateOfBirth ""
                                                                                           :name ""
                                                                                           :nationalIdentification ""}
                                                                              :language ""
                                                                              :payeeId ""
                                                                              :paymentChannel {:accountName ""
                                                                                               :accountNumber ""
                                                                                               :countryCode ""
                                                                                               :currency ""
                                                                                               :iban ""
                                                                                               :paymentChannelName ""
                                                                                               :routingNumber ""}
                                                                              :payorRefs [{:invitationStatus ""
                                                                                           :invitationStatusTimestamp ""
                                                                                           :payableIssues [{:code ""
                                                                                                            :message ""}]
                                                                                           :payableStatus false
                                                                                           :paymentChannelId ""
                                                                                           :payorId ""
                                                                                           :remoteId ""}]
                                                                              :remoteId ""
                                                                              :type ""}]
                                                                    :payorId ""}})
require "http/client"

url = "{{baseUrl}}/v3/payees"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payees"),
    Content = new StringContent("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees"

	payload := strings.NewReader("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")

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

	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))

}
POST /baseUrl/v3/payees HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1248

{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payees")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payees")
  .header("content-type", "application/json")
  .body("{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {
        description: '',
        value: ''
      },
      company: {
        name: '',
        operatingName: '',
        taxId: ''
      },
      email: '',
      individual: {
        dateOfBirth: '',
        name: '',
        nationalIdentification: ''
      },
      language: '',
      payeeId: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      payorRefs: [
        {
          invitationStatus: '',
          invitationStatusTimestamp: '',
          payableIssues: [
            {
              code: '',
              message: ''
            }
          ],
          payableStatus: false,
          paymentChannelId: '',
          payorId: '',
          remoteId: ''
        }
      ],
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payees');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees',
  headers: {'content-type': 'application/json'},
  data: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        payeeId: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        payorRefs: [
          {
            invitationStatus: '',
            invitationStatusTimestamp: '',
            payableIssues: [{code: '', message: ''}],
            payableStatus: false,
            paymentChannelId: '',
            payorId: '',
            remoteId: ''
          }
        ],
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payees":[{"address":{"city":"","country":"","countyOrProvince":"","line1":"","line2":"","line3":"","line4":"","zipOrPostcode":""},"challenge":{"description":"","value":""},"company":{"name":"","operatingName":"","taxId":""},"email":"","individual":{"dateOfBirth":"","name":"","nationalIdentification":""},"language":"","payeeId":"","paymentChannel":{"accountName":"","accountNumber":"","countryCode":"","currency":"","iban":"","paymentChannelName":"","routingNumber":""},"payorRefs":[{"invitationStatus":"","invitationStatusTimestamp":"","payableIssues":[{"code":"","message":""}],"payableStatus":false,"paymentChannelId":"","payorId":"","remoteId":""}],"remoteId":"","type":""}],"payorId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payees": [\n    {\n      "address": {\n        "city": "",\n        "country": "",\n        "countyOrProvince": "",\n        "line1": "",\n        "line2": "",\n        "line3": "",\n        "line4": "",\n        "zipOrPostcode": ""\n      },\n      "challenge": {\n        "description": "",\n        "value": ""\n      },\n      "company": {\n        "name": "",\n        "operatingName": "",\n        "taxId": ""\n      },\n      "email": "",\n      "individual": {\n        "dateOfBirth": "",\n        "name": "",\n        "nationalIdentification": ""\n      },\n      "language": "",\n      "payeeId": "",\n      "paymentChannel": {\n        "accountName": "",\n        "accountNumber": "",\n        "countryCode": "",\n        "currency": "",\n        "iban": "",\n        "paymentChannelName": "",\n        "routingNumber": ""\n      },\n      "payorRefs": [\n        {\n          "invitationStatus": "",\n          "invitationStatusTimestamp": "",\n          "payableIssues": [\n            {\n              "code": "",\n              "message": ""\n            }\n          ],\n          "payableStatus": false,\n          "paymentChannelId": "",\n          "payorId": "",\n          "remoteId": ""\n        }\n      ],\n      "remoteId": "",\n      "type": ""\n    }\n  ],\n  "payorId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {description: '', value: ''},
      company: {name: '', operatingName: '', taxId: ''},
      email: '',
      individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
      language: '',
      payeeId: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      payorRefs: [
        {
          invitationStatus: '',
          invitationStatusTimestamp: '',
          payableIssues: [{code: '', message: ''}],
          payableStatus: false,
          paymentChannelId: '',
          payorId: '',
          remoteId: ''
        }
      ],
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees',
  headers: {'content-type': 'application/json'},
  body: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        payeeId: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        payorRefs: [
          {
            invitationStatus: '',
            invitationStatusTimestamp: '',
            payableIssues: [{code: '', message: ''}],
            payableStatus: false,
            paymentChannelId: '',
            payorId: '',
            remoteId: ''
          }
        ],
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payees');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payees: [
    {
      address: {
        city: '',
        country: '',
        countyOrProvince: '',
        line1: '',
        line2: '',
        line3: '',
        line4: '',
        zipOrPostcode: ''
      },
      challenge: {
        description: '',
        value: ''
      },
      company: {
        name: '',
        operatingName: '',
        taxId: ''
      },
      email: '',
      individual: {
        dateOfBirth: '',
        name: '',
        nationalIdentification: ''
      },
      language: '',
      payeeId: '',
      paymentChannel: {
        accountName: '',
        accountNumber: '',
        countryCode: '',
        currency: '',
        iban: '',
        paymentChannelName: '',
        routingNumber: ''
      },
      payorRefs: [
        {
          invitationStatus: '',
          invitationStatusTimestamp: '',
          payableIssues: [
            {
              code: '',
              message: ''
            }
          ],
          payableStatus: false,
          paymentChannelId: '',
          payorId: '',
          remoteId: ''
        }
      ],
      remoteId: '',
      type: ''
    }
  ],
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees',
  headers: {'content-type': 'application/json'},
  data: {
    payees: [
      {
        address: {
          city: '',
          country: '',
          countyOrProvince: '',
          line1: '',
          line2: '',
          line3: '',
          line4: '',
          zipOrPostcode: ''
        },
        challenge: {description: '', value: ''},
        company: {name: '', operatingName: '', taxId: ''},
        email: '',
        individual: {dateOfBirth: '', name: '', nationalIdentification: ''},
        language: '',
        payeeId: '',
        paymentChannel: {
          accountName: '',
          accountNumber: '',
          countryCode: '',
          currency: '',
          iban: '',
          paymentChannelName: '',
          routingNumber: ''
        },
        payorRefs: [
          {
            invitationStatus: '',
            invitationStatusTimestamp: '',
            payableIssues: [{code: '', message: ''}],
            payableStatus: false,
            paymentChannelId: '',
            payorId: '',
            remoteId: ''
          }
        ],
        remoteId: '',
        type: ''
      }
    ],
    payorId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payees":[{"address":{"city":"","country":"","countyOrProvince":"","line1":"","line2":"","line3":"","line4":"","zipOrPostcode":""},"challenge":{"description":"","value":""},"company":{"name":"","operatingName":"","taxId":""},"email":"","individual":{"dateOfBirth":"","name":"","nationalIdentification":""},"language":"","payeeId":"","paymentChannel":{"accountName":"","accountNumber":"","countryCode":"","currency":"","iban":"","paymentChannelName":"","routingNumber":""},"payorRefs":[{"invitationStatus":"","invitationStatusTimestamp":"","payableIssues":[{"code":"","message":""}],"payableStatus":false,"paymentChannelId":"","payorId":"","remoteId":""}],"remoteId":"","type":""}],"payorId":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payees": @[ @{ @"address": @{ @"city": @"", @"country": @"", @"countyOrProvince": @"", @"line1": @"", @"line2": @"", @"line3": @"", @"line4": @"", @"zipOrPostcode": @"" }, @"challenge": @{ @"description": @"", @"value": @"" }, @"company": @{ @"name": @"", @"operatingName": @"", @"taxId": @"" }, @"email": @"", @"individual": @{ @"dateOfBirth": @"", @"name": @"", @"nationalIdentification": @"" }, @"language": @"", @"payeeId": @"", @"paymentChannel": @{ @"accountName": @"", @"accountNumber": @"", @"countryCode": @"", @"currency": @"", @"iban": @"", @"paymentChannelName": @"", @"routingNumber": @"" }, @"payorRefs": @[ @{ @"invitationStatus": @"", @"invitationStatusTimestamp": @"", @"payableIssues": @[ @{ @"code": @"", @"message": @"" } ], @"payableStatus": @NO, @"paymentChannelId": @"", @"payorId": @"", @"remoteId": @"" } ], @"remoteId": @"", @"type": @"" } ],
                              @"payorId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payees' => [
        [
                'address' => [
                                'city' => '',
                                'country' => '',
                                'countyOrProvince' => '',
                                'line1' => '',
                                'line2' => '',
                                'line3' => '',
                                'line4' => '',
                                'zipOrPostcode' => ''
                ],
                'challenge' => [
                                'description' => '',
                                'value' => ''
                ],
                'company' => [
                                'name' => '',
                                'operatingName' => '',
                                'taxId' => ''
                ],
                'email' => '',
                'individual' => [
                                'dateOfBirth' => '',
                                'name' => '',
                                'nationalIdentification' => ''
                ],
                'language' => '',
                'payeeId' => '',
                'paymentChannel' => [
                                'accountName' => '',
                                'accountNumber' => '',
                                'countryCode' => '',
                                'currency' => '',
                                'iban' => '',
                                'paymentChannelName' => '',
                                'routingNumber' => ''
                ],
                'payorRefs' => [
                                [
                                                                'invitationStatus' => '',
                                                                'invitationStatusTimestamp' => '',
                                                                'payableIssues' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'code' => '',
                                                                                                                                                                                                                                                                'message' => ''
                                                                                                                                ]
                                                                ],
                                                                'payableStatus' => null,
                                                                'paymentChannelId' => '',
                                                                'payorId' => '',
                                                                'remoteId' => ''
                                ]
                ],
                'remoteId' => '',
                'type' => ''
        ]
    ],
    'payorId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payees', [
  'body' => '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payees' => [
    [
        'address' => [
                'city' => '',
                'country' => '',
                'countyOrProvince' => '',
                'line1' => '',
                'line2' => '',
                'line3' => '',
                'line4' => '',
                'zipOrPostcode' => ''
        ],
        'challenge' => [
                'description' => '',
                'value' => ''
        ],
        'company' => [
                'name' => '',
                'operatingName' => '',
                'taxId' => ''
        ],
        'email' => '',
        'individual' => [
                'dateOfBirth' => '',
                'name' => '',
                'nationalIdentification' => ''
        ],
        'language' => '',
        'payeeId' => '',
        'paymentChannel' => [
                'accountName' => '',
                'accountNumber' => '',
                'countryCode' => '',
                'currency' => '',
                'iban' => '',
                'paymentChannelName' => '',
                'routingNumber' => ''
        ],
        'payorRefs' => [
                [
                                'invitationStatus' => '',
                                'invitationStatusTimestamp' => '',
                                'payableIssues' => [
                                                                [
                                                                                                                                'code' => '',
                                                                                                                                'message' => ''
                                                                ]
                                ],
                                'payableStatus' => null,
                                'paymentChannelId' => '',
                                'payorId' => '',
                                'remoteId' => ''
                ]
        ],
        'remoteId' => '',
        'type' => ''
    ]
  ],
  'payorId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payees' => [
    [
        'address' => [
                'city' => '',
                'country' => '',
                'countyOrProvince' => '',
                'line1' => '',
                'line2' => '',
                'line3' => '',
                'line4' => '',
                'zipOrPostcode' => ''
        ],
        'challenge' => [
                'description' => '',
                'value' => ''
        ],
        'company' => [
                'name' => '',
                'operatingName' => '',
                'taxId' => ''
        ],
        'email' => '',
        'individual' => [
                'dateOfBirth' => '',
                'name' => '',
                'nationalIdentification' => ''
        ],
        'language' => '',
        'payeeId' => '',
        'paymentChannel' => [
                'accountName' => '',
                'accountNumber' => '',
                'countryCode' => '',
                'currency' => '',
                'iban' => '',
                'paymentChannelName' => '',
                'routingNumber' => ''
        ],
        'payorRefs' => [
                [
                                'invitationStatus' => '',
                                'invitationStatusTimestamp' => '',
                                'payableIssues' => [
                                                                [
                                                                                                                                'code' => '',
                                                                                                                                'message' => ''
                                                                ]
                                ],
                                'payableStatus' => null,
                                'paymentChannelId' => '',
                                'payorId' => '',
                                'remoteId' => ''
                ]
        ],
        'remoteId' => '',
        'type' => ''
    ]
  ],
  'payorId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/payees');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payees", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees"

payload = {
    "payees": [
        {
            "address": {
                "city": "",
                "country": "",
                "countyOrProvince": "",
                "line1": "",
                "line2": "",
                "line3": "",
                "line4": "",
                "zipOrPostcode": ""
            },
            "challenge": {
                "description": "",
                "value": ""
            },
            "company": {
                "name": "",
                "operatingName": "",
                "taxId": ""
            },
            "email": "",
            "individual": {
                "dateOfBirth": "",
                "name": "",
                "nationalIdentification": ""
            },
            "language": "",
            "payeeId": "",
            "paymentChannel": {
                "accountName": "",
                "accountNumber": "",
                "countryCode": "",
                "currency": "",
                "iban": "",
                "paymentChannelName": "",
                "routingNumber": ""
            },
            "payorRefs": [
                {
                    "invitationStatus": "",
                    "invitationStatusTimestamp": "",
                    "payableIssues": [
                        {
                            "code": "",
                            "message": ""
                        }
                    ],
                    "payableStatus": False,
                    "paymentChannelId": "",
                    "payorId": "",
                    "remoteId": ""
                }
            ],
            "remoteId": "",
            "type": ""
        }
    ],
    "payorId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees"

payload <- "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payees') do |req|
  req.body = "{\n  \"payees\": [\n    {\n      \"address\": {\n        \"city\": \"\",\n        \"country\": \"\",\n        \"countyOrProvince\": \"\",\n        \"line1\": \"\",\n        \"line2\": \"\",\n        \"line3\": \"\",\n        \"line4\": \"\",\n        \"zipOrPostcode\": \"\"\n      },\n      \"challenge\": {\n        \"description\": \"\",\n        \"value\": \"\"\n      },\n      \"company\": {\n        \"name\": \"\",\n        \"operatingName\": \"\",\n        \"taxId\": \"\"\n      },\n      \"email\": \"\",\n      \"individual\": {\n        \"dateOfBirth\": \"\",\n        \"name\": \"\",\n        \"nationalIdentification\": \"\"\n      },\n      \"language\": \"\",\n      \"payeeId\": \"\",\n      \"paymentChannel\": {\n        \"accountName\": \"\",\n        \"accountNumber\": \"\",\n        \"countryCode\": \"\",\n        \"currency\": \"\",\n        \"iban\": \"\",\n        \"paymentChannelName\": \"\",\n        \"routingNumber\": \"\"\n      },\n      \"payorRefs\": [\n        {\n          \"invitationStatus\": \"\",\n          \"invitationStatusTimestamp\": \"\",\n          \"payableIssues\": [\n            {\n              \"code\": \"\",\n              \"message\": \"\"\n            }\n          ],\n          \"payableStatus\": false,\n          \"paymentChannelId\": \"\",\n          \"payorId\": \"\",\n          \"remoteId\": \"\"\n        }\n      ],\n      \"remoteId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"payorId\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees";

    let payload = json!({
        "payees": (
            json!({
                "address": json!({
                    "city": "",
                    "country": "",
                    "countyOrProvince": "",
                    "line1": "",
                    "line2": "",
                    "line3": "",
                    "line4": "",
                    "zipOrPostcode": ""
                }),
                "challenge": json!({
                    "description": "",
                    "value": ""
                }),
                "company": json!({
                    "name": "",
                    "operatingName": "",
                    "taxId": ""
                }),
                "email": "",
                "individual": json!({
                    "dateOfBirth": "",
                    "name": "",
                    "nationalIdentification": ""
                }),
                "language": "",
                "payeeId": "",
                "paymentChannel": json!({
                    "accountName": "",
                    "accountNumber": "",
                    "countryCode": "",
                    "currency": "",
                    "iban": "",
                    "paymentChannelName": "",
                    "routingNumber": ""
                }),
                "payorRefs": (
                    json!({
                        "invitationStatus": "",
                        "invitationStatusTimestamp": "",
                        "payableIssues": (
                            json!({
                                "code": "",
                                "message": ""
                            })
                        ),
                        "payableStatus": false,
                        "paymentChannelId": "",
                        "payorId": "",
                        "remoteId": ""
                    })
                ),
                "remoteId": "",
                "type": ""
            })
        ),
        "payorId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payees \
  --header 'content-type: application/json' \
  --data '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}'
echo '{
  "payees": [
    {
      "address": {
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      },
      "challenge": {
        "description": "",
        "value": ""
      },
      "company": {
        "name": "",
        "operatingName": "",
        "taxId": ""
      },
      "email": "",
      "individual": {
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      },
      "language": "",
      "payeeId": "",
      "paymentChannel": {
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      },
      "payorRefs": [
        {
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            {
              "code": "",
              "message": ""
            }
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        }
      ],
      "remoteId": "",
      "type": ""
    }
  ],
  "payorId": ""
}' |  \
  http POST {{baseUrl}}/v3/payees \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payees": [\n    {\n      "address": {\n        "city": "",\n        "country": "",\n        "countyOrProvince": "",\n        "line1": "",\n        "line2": "",\n        "line3": "",\n        "line4": "",\n        "zipOrPostcode": ""\n      },\n      "challenge": {\n        "description": "",\n        "value": ""\n      },\n      "company": {\n        "name": "",\n        "operatingName": "",\n        "taxId": ""\n      },\n      "email": "",\n      "individual": {\n        "dateOfBirth": "",\n        "name": "",\n        "nationalIdentification": ""\n      },\n      "language": "",\n      "payeeId": "",\n      "paymentChannel": {\n        "accountName": "",\n        "accountNumber": "",\n        "countryCode": "",\n        "currency": "",\n        "iban": "",\n        "paymentChannelName": "",\n        "routingNumber": ""\n      },\n      "payorRefs": [\n        {\n          "invitationStatus": "",\n          "invitationStatusTimestamp": "",\n          "payableIssues": [\n            {\n              "code": "",\n              "message": ""\n            }\n          ],\n          "payableStatus": false,\n          "paymentChannelId": "",\n          "payorId": "",\n          "remoteId": ""\n        }\n      ],\n      "remoteId": "",\n      "type": ""\n    }\n  ],\n  "payorId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/payees
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payees": [
    [
      "address": [
        "city": "",
        "country": "",
        "countyOrProvince": "",
        "line1": "",
        "line2": "",
        "line3": "",
        "line4": "",
        "zipOrPostcode": ""
      ],
      "challenge": [
        "description": "",
        "value": ""
      ],
      "company": [
        "name": "",
        "operatingName": "",
        "taxId": ""
      ],
      "email": "",
      "individual": [
        "dateOfBirth": "",
        "name": "",
        "nationalIdentification": ""
      ],
      "language": "",
      "payeeId": "",
      "paymentChannel": [
        "accountName": "",
        "accountNumber": "",
        "countryCode": "",
        "currency": "",
        "iban": "",
        "paymentChannelName": "",
        "routingNumber": ""
      ],
      "payorRefs": [
        [
          "invitationStatus": "",
          "invitationStatusTimestamp": "",
          "payableIssues": [
            [
              "code": "",
              "message": ""
            ]
          ],
          "payableStatus": false,
          "paymentChannelId": "",
          "payorId": "",
          "remoteId": ""
        ]
      ],
      "remoteId": "",
      "type": ""
    ]
  ],
  "payorId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "batchId": "cb6ff8c6-85e9-45a6-b7d9-d05305db67f3",
  "rejectedCsvRows": [
    {
      "lineNumber": 3,
      "message": "rejected message 1",
      "rejectedContent": "unable,to,process,csv,line"
    },
    {
      "lineNumber": 3,
      "message": "rejected message 1",
      "rejectedContent": "unable,to,process,csv,line"
    }
  ]
}
GET Query Batch Status (GET)
{{baseUrl}}/v4/payees/batch/:batchId
QUERY PARAMS

batchId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/batch/:batchId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payees/batch/:batchId")
require "http/client"

url = "{{baseUrl}}/v4/payees/batch/:batchId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/batch/:batchId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/batch/:batchId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/batch/:batchId"

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

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

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

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

}
GET /baseUrl/v4/payees/batch/:batchId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payees/batch/:batchId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/batch/:batchId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/batch/:batchId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payees/batch/:batchId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payees/batch/:batchId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/batch/:batchId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/batch/:batchId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/batch/:batchId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/batch/:batchId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/batch/:batchId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/batch/:batchId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payees/batch/:batchId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/batch/:batchId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/batch/:batchId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/batch/:batchId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/batch/:batchId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/batch/:batchId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payees/batch/:batchId');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/batch/:batchId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees/batch/:batchId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/batch/:batchId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/batch/:batchId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payees/batch/:batchId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/batch/:batchId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/batch/:batchId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/batch/:batchId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payees/batch/:batchId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/batch/:batchId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/payees/batch/:batchId
http GET {{baseUrl}}/v4/payees/batch/:batchId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/payees/batch/:batchId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/batch/:batchId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "failureCount": 2,
  "failures": [
    {
      "failedSubmission": {
        "address": {
          "city": "Key West",
          "country": "US",
          "countyOrProvince": "FL",
          "line1": "500 Duval St",
          "line2": "line2",
          "line3": "line3",
          "line4": "line4",
          "zipOrPostcode": "33945"
        },
        "challenge": {
          "description": "challenge description",
          "value": "11984567"
        },
        "company": {
          "name": "ABC Group Plc",
          "operatingName": "ABC Co",
          "taxId": "123123123"
        },
        "email": "bob@example.com",
        "individual": {
          "dateOfBirth": "1970-05-20T00:00:00.000+0000",
          "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "H",
            "title": "Mr"
          },
          "nationalIdentification": "SA211123K"
        },
        "language": "en-US",
        "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
        "paymentChannel": {
          "accountName": "My account",
          "accountNumber": "XXXXXX5678",
          "countryCode": "US",
          "currency": "USD",
          "iban": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1234",
          "paymentChannelName": "My Payment Channel",
          "routingNumber": "XXXXX6789"
        },
        "payorRefs": [
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          },
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          }
        ],
        "remoteId": "Remote ID",
        "type": "type"
      },
      "failureMessage": "failure reason"
    },
    {
      "failedSubmission": {
        "address": {
          "city": "Key West",
          "country": "US",
          "countyOrProvince": "FL",
          "line1": "500 Duval St",
          "line2": "line2",
          "line3": "line3",
          "line4": "line4",
          "zipOrPostcode": "33945"
        },
        "challenge": {
          "description": "challenge description",
          "value": "11984567"
        },
        "company": {
          "name": "ABC Group Plc",
          "operatingName": "ABC Co",
          "taxId": "123123123"
        },
        "email": "bob@example.com",
        "individual": {
          "dateOfBirth": "1970-05-20T00:00:00.000+0000",
          "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "H",
            "title": "Mr"
          },
          "nationalIdentification": "SA211123K"
        },
        "language": "en-US",
        "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
        "paymentChannel": {
          "accountName": "My account",
          "accountNumber": "XXXXXX5678",
          "countryCode": "US",
          "currency": "USD",
          "iban": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1234",
          "paymentChannelName": "My Payment Channel",
          "routingNumber": "XXXXX6789"
        },
        "payorRefs": [
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          },
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          }
        ],
        "remoteId": "Remote ID",
        "type": "type"
      },
      "failureMessage": "failure reason"
    }
  ],
  "pendingCount": 2,
  "status": "status"
}
GET Query Batch Status
{{baseUrl}}/v3/payees/batch/:batchId
QUERY PARAMS

batchId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/batch/:batchId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payees/batch/:batchId")
require "http/client"

url = "{{baseUrl}}/v3/payees/batch/:batchId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/batch/:batchId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/batch/:batchId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/batch/:batchId"

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

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

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

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

}
GET /baseUrl/v3/payees/batch/:batchId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payees/batch/:batchId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/batch/:batchId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/batch/:batchId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payees/batch/:batchId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payees/batch/:batchId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/batch/:batchId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/batch/:batchId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/batch/:batchId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/batch/:batchId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/batch/:batchId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/batch/:batchId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payees/batch/:batchId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/batch/:batchId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/batch/:batchId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/batch/:batchId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/batch/:batchId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/batch/:batchId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payees/batch/:batchId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/batch/:batchId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees/batch/:batchId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/batch/:batchId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/batch/:batchId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payees/batch/:batchId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/batch/:batchId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/batch/:batchId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/batch/:batchId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payees/batch/:batchId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/batch/:batchId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/payees/batch/:batchId
http GET {{baseUrl}}/v3/payees/batch/:batchId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/payees/batch/:batchId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/batch/:batchId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "failureCount": 2,
  "failures": [
    {
      "failedSubmission": {
        "address": {
          "city": "Key West",
          "country": "US",
          "countyOrProvince": "FL",
          "line1": "500 Duval St",
          "line2": "line2",
          "line3": "line3",
          "line4": "line4",
          "zipOrPostcode": "33945"
        },
        "challenge": {
          "description": "challenge description",
          "value": "challenge test"
        },
        "company": {
          "name": "ABC Group Plc",
          "operatingName": "ABC Co",
          "taxId": "123123123"
        },
        "email": "bob@example.com",
        "individual": {
          "dateOfBirth": "1970-05-20T00:00:00.000+0000",
          "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "H",
            "title": "Mr"
          },
          "nationalIdentification": "SA211123K"
        },
        "language": "en-US",
        "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
        "paymentChannel": {
          "accountName": "My account",
          "accountNumber": "XXXXXX5678",
          "countryCode": "US",
          "currency": "USD",
          "iban": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1234",
          "paymentChannelName": "My Payment Channel",
          "routingNumber": "XXXXX6789"
        },
        "payorRefs": [
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          },
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          }
        ],
        "remoteId": "Remote ID",
        "type": "type"
      },
      "failureMessage": "failure reason"
    },
    {
      "failedSubmission": {
        "address": {
          "city": "Key West",
          "country": "US",
          "countyOrProvince": "FL",
          "line1": "500 Duval St",
          "line2": "line2",
          "line3": "line3",
          "line4": "line4",
          "zipOrPostcode": "33945"
        },
        "challenge": {
          "description": "challenge description",
          "value": "challenge test"
        },
        "company": {
          "name": "ABC Group Plc",
          "operatingName": "ABC Co",
          "taxId": "123123123"
        },
        "email": "bob@example.com",
        "individual": {
          "dateOfBirth": "1970-05-20T00:00:00.000+0000",
          "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "H",
            "title": "Mr"
          },
          "nationalIdentification": "SA211123K"
        },
        "language": "en-US",
        "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
        "paymentChannel": {
          "accountName": "My account",
          "accountNumber": "XXXXXX5678",
          "countryCode": "US",
          "currency": "USD",
          "iban": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1234",
          "paymentChannelName": "My Payment Channel",
          "routingNumber": "XXXXX6789"
        },
        "payorRefs": [
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          },
          {
            "invitationStatus": "invitationStatus",
            "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
            "payableIssues": [
              {
                "code": "3",
                "message": "payee-disabled"
              },
              {
                "code": "3",
                "message": "payee-disabled"
              }
            ],
            "payableStatus": true,
            "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
            "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
            "remoteId": "uniqueIdForRemoteEntity"
          }
        ],
        "remoteId": "Remote ID",
        "type": "type"
      },
      "failureMessage": "failure reason"
    }
  ],
  "pendingCount": 2,
  "status": "status"
}
POST Resend Payee Invite (POST)
{{baseUrl}}/v4/payees/:payeeId/invite
QUERY PARAMS

payeeId
BODY json

{
  "payorId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/:payeeId/invite");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v4/payees/:payeeId/invite" {:content-type :json
                                                                      :form-params {:payorId "9ac75325-5dcd-42d5-b992-175d7e0a035e"}})
require "http/client"

url = "{{baseUrl}}/v4/payees/:payeeId/invite"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/:payeeId/invite"),
    Content = new StringContent("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/:payeeId/invite");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/:payeeId/invite"

	payload := strings.NewReader("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")

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

	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))

}
POST /baseUrl/v4/payees/:payeeId/invite HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v4/payees/:payeeId/invite")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/:payeeId/invite"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v4/payees/:payeeId/invite")
  .header("content-type", "application/json")
  .body("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
  .asString();
const data = JSON.stringify({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v4/payees/:payeeId/invite');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/:payeeId/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/:payeeId/invite',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/:payeeId/invite',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  body: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v4/payees/:payeeId/invite');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/:payeeId/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payorId": @"9ac75325-5dcd-42d5-b992-175d7e0a035e" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/:payeeId/invite"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/:payeeId/invite" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/:payeeId/invite",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v4/payees/:payeeId/invite', [
  'body' => '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/:payeeId/invite');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
]));
$request->setRequestUrl('{{baseUrl}}/v4/payees/:payeeId/invite');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/:payeeId/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/:payeeId/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v4/payees/:payeeId/invite", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/:payeeId/invite"

payload = { "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/:payeeId/invite"

payload <- "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/:payeeId/invite")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v4/payees/:payeeId/invite') do |req|
  req.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/:payeeId/invite";

    let payload = json!({"payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v4/payees/:payeeId/invite \
  --header 'content-type: application/json' \
  --data '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
echo '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}' |  \
  http POST {{baseUrl}}/v4/payees/:payeeId/invite \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"\n}' \
  --output-document \
  - {{baseUrl}}/v4/payees/:payeeId/invite
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/:payeeId/invite")! 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()
POST Resend Payee Invite
{{baseUrl}}/v3/payees/:payeeId/invite
QUERY PARAMS

payeeId
BODY json

{
  "payorId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/:payeeId/invite");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payees/:payeeId/invite" {:content-type :json
                                                                      :form-params {:payorId "9ac75325-5dcd-42d5-b992-175d7e0a035e"}})
require "http/client"

url = "{{baseUrl}}/v3/payees/:payeeId/invite"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/:payeeId/invite"),
    Content = new StringContent("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/:payeeId/invite");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/:payeeId/invite"

	payload := strings.NewReader("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")

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

	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))

}
POST /baseUrl/v3/payees/:payeeId/invite HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payees/:payeeId/invite")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/:payeeId/invite"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payees/:payeeId/invite")
  .header("content-type", "application/json")
  .body("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
  .asString();
const data = JSON.stringify({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payees/:payeeId/invite');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/:payeeId/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/:payeeId/invite',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/:payeeId/invite',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  body: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payees/:payeeId/invite');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/invite',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/:payeeId/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payorId": @"9ac75325-5dcd-42d5-b992-175d7e0a035e" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/:payeeId/invite"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/:payeeId/invite" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/:payeeId/invite",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payees/:payeeId/invite', [
  'body' => '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/:payeeId/invite');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e'
]));
$request->setRequestUrl('{{baseUrl}}/v3/payees/:payeeId/invite');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/:payeeId/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/:payeeId/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payees/:payeeId/invite", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/:payeeId/invite"

payload = { "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/:payeeId/invite"

payload <- "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/:payeeId/invite")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payees/:payeeId/invite') do |req|
  req.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/:payeeId/invite";

    let payload = json!({"payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payees/:payeeId/invite \
  --header 'content-type: application/json' \
  --data '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}'
echo '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"
}' |  \
  http POST {{baseUrl}}/v3/payees/:payeeId/invite \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"\n}' \
  --output-document \
  - {{baseUrl}}/v3/payees/:payeeId/invite
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/:payeeId/invite")! 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()
DELETE Delete Payee by Id (DELETE)
{{baseUrl}}/v4/payees/:payeeId
QUERY PARAMS

payeeId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/:payeeId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v4/payees/:payeeId")
require "http/client"

url = "{{baseUrl}}/v4/payees/:payeeId"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/:payeeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/:payeeId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/:payeeId"

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

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

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

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

}
DELETE /baseUrl/v4/payees/:payeeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v4/payees/:payeeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/:payeeId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v4/payees/:payeeId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v4/payees/:payeeId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v4/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/:payeeId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/:payeeId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/:payeeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v4/payees/:payeeId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v4/payees/:payeeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v4/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/:payeeId';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/:payeeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/:payeeId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/:payeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v4/payees/:payeeId');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/:payeeId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees/:payeeId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/:payeeId' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/:payeeId' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v4/payees/:payeeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/:payeeId"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/:payeeId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/:payeeId")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v4/payees/:payeeId') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/:payeeId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v4/payees/:payeeId
http DELETE {{baseUrl}}/v4/payees/:payeeId
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v4/payees/:payeeId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/:payeeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
DELETE Delete Payee by Id
{{baseUrl}}/v3/payees/:payeeId
QUERY PARAMS

payeeId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/:payeeId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v3/payees/:payeeId")
require "http/client"

url = "{{baseUrl}}/v3/payees/:payeeId"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/:payeeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/:payeeId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/:payeeId"

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

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

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

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

}
DELETE /baseUrl/v3/payees/:payeeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/payees/:payeeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/:payeeId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v3/payees/:payeeId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v3/payees/:payeeId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/:payeeId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/:payeeId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/:payeeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payees/:payeeId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/payees/:payeeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/:payeeId';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/:payeeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/:payeeId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/:payeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v3/payees/:payeeId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/:payeeId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees/:payeeId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/:payeeId' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/:payeeId' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v3/payees/:payeeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/:payeeId"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/:payeeId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/:payeeId")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v3/payees/:payeeId') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/:payeeId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v3/payees/:payeeId
http DELETE {{baseUrl}}/v3/payees/:payeeId
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/payees/:payeeId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/:payeeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
GET Get Payee by Id (GET)
{{baseUrl}}/v4/payees/:payeeId
QUERY PARAMS

payeeId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/:payeeId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payees/:payeeId")
require "http/client"

url = "{{baseUrl}}/v4/payees/:payeeId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/:payeeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/:payeeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/:payeeId"

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

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

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

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

}
GET /baseUrl/v4/payees/:payeeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payees/:payeeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/:payeeId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payees/:payeeId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payees/:payeeId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/:payeeId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/:payeeId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/:payeeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/:payeeId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payees/:payeeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/:payeeId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/:payeeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/:payeeId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/:payeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payees/:payeeId');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/:payeeId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees/:payeeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/:payeeId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/:payeeId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payees/:payeeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/:payeeId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/:payeeId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/:payeeId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payees/:payeeId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/:payeeId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/payees/:payeeId
http GET {{baseUrl}}/v4/payees/:payeeId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/payees/:payeeId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/:payeeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "acceptTermsAndConditionsTimestamp": "2019-01-20T09:00:00Z",
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "cellphoneNumber": "1234567890",
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "country": "US",
  "created": "2019-01-20T09:00:00Z",
  "disabled": true,
  "disabledComment": "reason for disabled",
  "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
  "displayName": "Bob",
  "email": "bob@example.com",
  "enhancedKycCompleted": true,
  "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "kycCompletedTimestamp": "2019-01-20T09:00:00+00:00",
  "language": "en-US",
  "marketingOptInDecision": true,
  "marketingOptInTimestamp": "2019-01-20T09:00:00+00:00",
  "onboardedStatus": "onboardedStatus",
  "pausePayment": true,
  "pausePaymentTimestamp": "2019-01-20T09:00:00+00:00",
  "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
  "payeeType": "payeeType",
  "payorRefs": [
    {
      "invitationStatus": "invitationStatus",
      "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
      "payableIssues": [
        {
          "code": "3",
          "message": "payee-disabled"
        },
        {
          "code": "3",
          "message": "payee-disabled"
        }
      ],
      "payableStatus": true,
      "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
      "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
      "remoteId": "uniqueIdForRemoteEntity"
    },
    {
      "invitationStatus": "invitationStatus",
      "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
      "payableIssues": [
        {
          "code": "3",
          "message": "payee-disabled"
        },
        {
          "code": "3",
          "message": "payee-disabled"
        }
      ],
      "payableStatus": true,
      "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
      "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
      "remoteId": "uniqueIdForRemoteEntity"
    }
  ],
  "watchlistOverrideComment": "watchlist override comment",
  "watchlistOverrideExpiresAtTimestamp": "2019-01-20T09:00:00Z",
  "watchlistStatus": "watchlistStatus",
  "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
}
GET Get Payee by Id
{{baseUrl}}/v3/payees/:payeeId
QUERY PARAMS

payeeId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/:payeeId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payees/:payeeId")
require "http/client"

url = "{{baseUrl}}/v3/payees/:payeeId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/:payeeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/:payeeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/:payeeId"

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

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

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

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

}
GET /baseUrl/v3/payees/:payeeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payees/:payeeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/:payeeId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payees/:payeeId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payees/:payeeId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/:payeeId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/:payeeId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/:payeeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/:payeeId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payees/:payeeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees/:payeeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/:payeeId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/:payeeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/:payeeId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/:payeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payees/:payeeId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/:payeeId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees/:payeeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/:payeeId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/:payeeId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payees/:payeeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/:payeeId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/:payeeId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/:payeeId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payees/:payeeId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/:payeeId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/payees/:payeeId
http GET {{baseUrl}}/v3/payees/:payeeId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/payees/:payeeId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/:payeeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "acceptTermsAndConditionsTimestamp": "2019-01-20T09:00:00Z",
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "cellphoneNumber": "1234567890",
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "country": "US",
  "created": "2019-01-20T09:00:00Z",
  "disabled": true,
  "disabledComment": "reason for disabled",
  "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
  "displayName": "Bob",
  "email": "bob@example.com",
  "enhancedKycCompleted": true,
  "gracePeriodEndDate": "2019-01-20T00:00:00.000+0000",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "kycCompletedTimestamp": "2019-01-20T09:00:00+00:00",
  "language": "en-US",
  "marketingOptInDecision": true,
  "marketingOptInTimestamp": "2019-01-20T09:00:00+00:00",
  "onboardedStatus": "onboardedStatus",
  "pausePayment": true,
  "pausePaymentTimestamp": "2019-01-20T09:00:00+00:00",
  "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
  "payeeType": "payeeType",
  "payorRefs": [
    {
      "invitationStatus": "invitationStatus",
      "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
      "payableIssues": [
        {
          "code": "3",
          "message": "payee-disabled"
        },
        {
          "code": "3",
          "message": "payee-disabled"
        }
      ],
      "payableStatus": true,
      "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
      "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
      "remoteId": "uniqueIdForRemoteEntity"
    },
    {
      "invitationStatus": "invitationStatus",
      "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
      "payableIssues": [
        {
          "code": "3",
          "message": "payee-disabled"
        },
        {
          "code": "3",
          "message": "payee-disabled"
        }
      ],
      "payableStatus": true,
      "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
      "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
      "remoteId": "uniqueIdForRemoteEntity"
    }
  ],
  "watchlistOverrideComment": "watchlist override comment",
  "watchlistOverrideExpiresAtTimestamp": "2019-01-20T09:00:00Z",
  "watchlistStatus": "watchlistStatus",
  "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
}
GET List Payee Changes (GET)
{{baseUrl}}/v4/payees/deltas
QUERY PARAMS

payorId
updatedSince
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payees/deltas" {:query-params {:payorId ""
                                                                           :updatedSince ""}})
require "http/client"

url = "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince="

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

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

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

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

}
GET /baseUrl/v4/payees/deltas?payorId=&updatedSince= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/deltas?payorId=&updatedSince=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/deltas',
  qs: {payorId: '', updatedSince: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payees/deltas');

req.query({
  payorId: '',
  updatedSince: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/deltas');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => '',
  'updatedSince' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees/deltas');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => '',
  'updatedSince' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payees/deltas?payorId=&updatedSince=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/deltas"

querystring = {"payorId":"","updatedSince":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/deltas"

queryString <- list(
  payorId = "",
  updatedSince = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payees/deltas') do |req|
  req.params['payorId'] = ''
  req.params['updatedSince'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/deltas";

    let querystring = [
        ("payorId", ""),
        ("updatedSince", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince='
http GET '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/deltas?payorId=&updatedSince=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "dbaName": "Payee DBA Name",
      "displayName": "Payee1",
      "email": "payee1@example.com",
      "onboardedStatus": "onboardedStatus",
      "payeeCountry": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "remoteId": "payee_1"
    },
    {
      "dbaName": "Payee DBA Name",
      "displayName": "Payee1",
      "email": "payee1@example.com",
      "onboardedStatus": "onboardedStatus",
      "payeeCountry": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "remoteId": "payee_1"
    }
  ],
  "links": [
    {
      "href": "http://api.sandbox.velopayments.com/v4/payees/deltas?payorId=0a818933-087d-47f2-ad83-2f986ed087eb&updatedSince=2019-01-20T09:00:00+00:00&page=1&pageSize=1000",
      "rel": "first"
    },
    {
      "href": "http://api.sandbox.velopayments.com/v4/payees/deltas?payorId=0a818933-087d-47f2-ad83-2f986ed087eb&updatedSince=2019-01-20T09:00:00+00:00&page=1&pageSize=1000",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 2,
    "page": 1,
    "pageSize": 25,
    "totalElements": 2,
    "totalPages": 1
  }
}
GET List Payee Changes
{{baseUrl}}/v3/payees/deltas
QUERY PARAMS

payorId
updatedSince
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payees/deltas" {:query-params {:payorId ""
                                                                           :updatedSince ""}})
require "http/client"

url = "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince="

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

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

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

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

}
GET /baseUrl/v3/payees/deltas?payorId=&updatedSince= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/deltas?payorId=&updatedSince=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/deltas',
  qs: {payorId: '', updatedSince: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payees/deltas');

req.query({
  payorId: '',
  updatedSince: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/deltas');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => '',
  'updatedSince' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees/deltas');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => '',
  'updatedSince' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payees/deltas?payorId=&updatedSince=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/deltas"

querystring = {"payorId":"","updatedSince":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/deltas"

queryString <- list(
  payorId = "",
  updatedSince = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payees/deltas') do |req|
  req.params['payorId'] = ''
  req.params['updatedSince'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/deltas";

    let querystring = [
        ("payorId", ""),
        ("updatedSince", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince='
http GET '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/deltas?payorId=&updatedSince=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "dbaName": "Payee DBA Name",
      "displayName": "Payee1",
      "email": "payee1@example.com",
      "onboardedStatus": "onboardedStatus",
      "payeeCountry": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "remoteId": "payee_1"
    },
    {
      "dbaName": "Payee DBA Name",
      "displayName": "Payee1",
      "email": "payee1@example.com",
      "onboardedStatus": "onboardedStatus",
      "payeeCountry": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "remoteId": "payee_1"
    }
  ],
  "links": [
    {
      "href": "http://api.sandbox.velopayments.com/v3/payees/deltas?payorId=0a818933-087d-47f2-ad83-2f986ed087eb&updatedSince=2019-01-20T09:00:00+00:00&page=1&pageSize=1000",
      "rel": "first"
    },
    {
      "href": "http://api.sandbox.velopayments.com/v3/payees/deltas?payorId=0a818933-087d-47f2-ad83-2f986ed087eb&updatedSince=2019-01-20T09:00:00+00:00&page=1&pageSize=1000",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 2,
    "page": 1,
    "pageSize": 25,
    "totalElements": 2,
    "totalPages": 1
  }
}
GET List Payees (GET)
{{baseUrl}}/v4/payees
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payees" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v4/payees?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payees?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees?payorId="

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

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

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

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

}
GET /baseUrl/v4/payees?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payees?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payees?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payees?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/payees', qs: {payorId: ''}};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payees');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payees',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payees?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payees');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payees?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payees') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v4/payees?payorId='
http GET '{{baseUrl}}/v4/payees?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v4/payees?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co"
      },
      "country": "US",
      "created": "2019-01-20T09:00:00Z",
      "disabled": true,
      "disabledComment": "reason for disabled",
      "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
      "displayName": "ABC",
      "email": "bob@example.com",
      "individual": {
        "name": {
          "firstName": "Bob",
          "lastName": "Smith",
          "otherNames": "H",
          "title": "Mr"
        }
      },
      "language": "en-US",
      "onboardedStatus": "onboardedStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
      "payeeType": "payeeType",
      "payorRefs": [
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        },
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        }
      ],
      "watchlistOverrideComment": "Example reason for the watchlist status being overridden",
      "watchlistStatus": "watchlistStatus",
      "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
    },
    {
      "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co"
      },
      "country": "US",
      "created": "2019-01-20T09:00:00Z",
      "disabled": true,
      "disabledComment": "reason for disabled",
      "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
      "displayName": "ABC",
      "email": "bob@example.com",
      "individual": {
        "name": {
          "firstName": "Bob",
          "lastName": "Smith",
          "otherNames": "H",
          "title": "Mr"
        }
      },
      "language": "en-US",
      "onboardedStatus": "onboardedStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
      "payeeType": "payeeType",
      "payorRefs": [
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        },
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        }
      ],
      "watchlistOverrideComment": "Example reason for the watchlist status being overridden",
      "watchlistStatus": "watchlistStatus",
      "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 10,
    "page": 10,
    "pageSize": 10,
    "totalElements": 10,
    "totalPages": 10
  },
  "summary": {
    "totalInvitedCount": 10,
    "totalOnboardedCount": 10,
    "totalPayeesCount": 10,
    "totalRegisteredCount": 10,
    "totalWatchlistFailedCount": 0
  }
}
GET List Payees
{{baseUrl}}/v3/payees
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payees" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v3/payees?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payees?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees?payorId="

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

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

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

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

}
GET /baseUrl/v3/payees?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payees?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payees?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payees?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/payees', qs: {payorId: ''}};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payees');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payees',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payees?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payees');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payees?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payees') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v3/payees?payorId='
http GET '{{baseUrl}}/v3/payees?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/payees?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co"
      },
      "country": "US",
      "created": "2019-01-20T09:00:00Z",
      "disabled": true,
      "disabledComment": "reason for disabled",
      "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
      "displayName": "ABC",
      "email": "bob@example.com",
      "individual": {
        "name": {
          "firstName": "Bob",
          "lastName": "Smith",
          "otherNames": "H",
          "title": "Mr"
        }
      },
      "language": "en-US",
      "onboardedStatus": "onboardedStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
      "payeeType": "payeeType",
      "payorRefs": [
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        },
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        }
      ],
      "watchlistOverrideComment": "Example reason for the watchlist status being overridden",
      "watchlistStatus": "watchlistStatus",
      "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
    },
    {
      "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co"
      },
      "country": "US",
      "created": "2019-01-20T09:00:00Z",
      "disabled": true,
      "disabledComment": "reason for disabled",
      "disabledUpdatedTimestamp": "2019-01-20T09:00:00Z",
      "displayName": "ABC",
      "email": "bob@example.com",
      "individual": {
        "name": {
          "firstName": "Bob",
          "lastName": "Smith",
          "otherNames": "H",
          "title": "Mr"
        }
      },
      "language": "en-US",
      "onboardedStatus": "onboardedStatus",
      "payeeId": "2aa5d7e0-2ecb-403f-8494-1865ed0454e9",
      "payeeType": "payeeType",
      "payorRefs": [
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        },
        {
          "invitationStatus": "invitationStatus",
          "invitationStatusTimestamp": "2019-01-20T09:00:00Z",
          "payableIssues": [
            {
              "code": "3",
              "message": "payee-disabled"
            },
            {
              "code": "3",
              "message": "payee-disabled"
            }
          ],
          "payableStatus": true,
          "paymentChannelId": "70faaff7-2c32-4b44-b27f-f0b6c484e6f3",
          "payorId": "ba08877f-9d96-41e4-9c26-44a872d856ae",
          "remoteId": "uniqueIdForRemoteEntity"
        }
      ],
      "watchlistOverrideComment": "Example reason for the watchlist status being overridden",
      "watchlistStatus": "watchlistStatus",
      "watchlistStatusUpdatedTimestamp": "2019-01-20T09:00:00+00:00"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 10,
    "page": 10,
    "pageSize": 10,
    "totalElements": 10,
    "totalPages": 10
  },
  "summary": {
    "totalInvitedCount": 10,
    "totalOnboardedCount": 10,
    "totalPayeesCount": 10,
    "totalRegisteredCount": 10,
    "totalWatchlistFailedCount": 0
  }
}
POST Update Payee Details (POST)
{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate
QUERY PARAMS

payeeId
BODY json

{
  "address": {
    "city": "",
    "country": "",
    "countyOrProvince": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "line4": "",
    "zipOrPostcode": ""
  },
  "challenge": {
    "description": "",
    "value": ""
  },
  "company": {
    "name": "",
    "operatingName": "",
    "taxId": ""
  },
  "contactSmsNumber": "",
  "email": "",
  "individual": {
    "dateOfBirth": "",
    "name": "",
    "nationalIdentification": ""
  },
  "language": "",
  "payeeType": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate" {:content-type :json
                                                                                  :form-params {:address {:city "Key West"
                                                                                                          :country "US"
                                                                                                          :countyOrProvince "FL"
                                                                                                          :line1 "500 Duval St"
                                                                                                          :line2 "line2"
                                                                                                          :line3 "line3"
                                                                                                          :line4 "line4"
                                                                                                          :zipOrPostcode "33945"}
                                                                                                :challenge {:description "challenge description"
                                                                                                            :value "11984567"}
                                                                                                :company {:name "ABC Group Plc"
                                                                                                          :operatingName "ABC Co"
                                                                                                          :taxId "123123123"}
                                                                                                :contactSmsNumber "11235555555"
                                                                                                :email "bob@example.com"
                                                                                                :individual {:dateOfBirth "1985-01-01"
                                                                                                             :name {:firstName "Bob"
                                                                                                                    :lastName "Smith"
                                                                                                                    :otherNames "A"
                                                                                                                    :title "Mr"}
                                                                                                             :nationalIdentification "AB123456C"}
                                                                                                :language "en-US"}})
require "http/client"

url = "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")

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

	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))

}
POST /baseUrl/v4/payees/:payeeId/payeeDetailsUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 723

{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
  .asString();
const data = JSON.stringify({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {
    description: 'challenge description',
    value: '11984567'
  },
  company: {
    name: 'ABC Group Plc',
    operatingName: 'ABC Co',
    taxId: '123123123'
  },
  contactSmsNumber: '11235555555',
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {
      firstName: 'Bob',
      lastName: 'Smith',
      otherNames: 'A',
      title: 'Mr'
    },
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: '11984567'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    contactSmsNumber: '11235555555',
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"Key West","country":"US","countyOrProvince":"FL","line1":"500 Duval St","line2":"line2","line3":"line3","line4":"line4","zipOrPostcode":"33945"},"challenge":{"description":"challenge description","value":"11984567"},"company":{"name":"ABC Group Plc","operatingName":"ABC Co","taxId":"123123123"},"contactSmsNumber":"11235555555","email":"bob@example.com","individual":{"dateOfBirth":"1985-01-01","name":{"firstName":"Bob","lastName":"Smith","otherNames":"A","title":"Mr"},"nationalIdentification":"AB123456C"},"language":"en-US"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "Key West",\n    "country": "US",\n    "countyOrProvince": "FL",\n    "line1": "500 Duval St",\n    "line2": "line2",\n    "line3": "line3",\n    "line4": "line4",\n    "zipOrPostcode": "33945"\n  },\n  "challenge": {\n    "description": "challenge description",\n    "value": "11984567"\n  },\n  "company": {\n    "name": "ABC Group Plc",\n    "operatingName": "ABC Co",\n    "taxId": "123123123"\n  },\n  "contactSmsNumber": "11235555555",\n  "email": "bob@example.com",\n  "individual": {\n    "dateOfBirth": "1985-01-01",\n    "name": {\n      "firstName": "Bob",\n      "lastName": "Smith",\n      "otherNames": "A",\n      "title": "Mr"\n    },\n    "nationalIdentification": "AB123456C"\n  },\n  "language": "en-US"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/:payeeId/payeeDetailsUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {description: 'challenge description', value: '11984567'},
  company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
  contactSmsNumber: '11235555555',
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  body: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: '11984567'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    contactSmsNumber: '11235555555',
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {
    description: 'challenge description',
    value: '11984567'
  },
  company: {
    name: 'ABC Group Plc',
    operatingName: 'ABC Co',
    taxId: '123123123'
  },
  contactSmsNumber: '11235555555',
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {
      firstName: 'Bob',
      lastName: 'Smith',
      otherNames: 'A',
      title: 'Mr'
    },
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: '11984567'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    contactSmsNumber: '11235555555',
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"Key West","country":"US","countyOrProvince":"FL","line1":"500 Duval St","line2":"line2","line3":"line3","line4":"line4","zipOrPostcode":"33945"},"challenge":{"description":"challenge description","value":"11984567"},"company":{"name":"ABC Group Plc","operatingName":"ABC Co","taxId":"123123123"},"contactSmsNumber":"11235555555","email":"bob@example.com","individual":{"dateOfBirth":"1985-01-01","name":{"firstName":"Bob","lastName":"Smith","otherNames":"A","title":"Mr"},"nationalIdentification":"AB123456C"},"language":"en-US"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address": @{ @"city": @"Key West", @"country": @"US", @"countyOrProvince": @"FL", @"line1": @"500 Duval St", @"line2": @"line2", @"line3": @"line3", @"line4": @"line4", @"zipOrPostcode": @"33945" },
                              @"challenge": @{ @"description": @"challenge description", @"value": @"11984567" },
                              @"company": @{ @"name": @"ABC Group Plc", @"operatingName": @"ABC Co", @"taxId": @"123123123" },
                              @"contactSmsNumber": @"11235555555",
                              @"email": @"bob@example.com",
                              @"individual": @{ @"dateOfBirth": @"1985-01-01", @"name": @{ @"firstName": @"Bob", @"lastName": @"Smith", @"otherNames": @"A", @"title": @"Mr" }, @"nationalIdentification": @"AB123456C" },
                              @"language": @"en-US" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => [
        'city' => 'Key West',
        'country' => 'US',
        'countyOrProvince' => 'FL',
        'line1' => '500 Duval St',
        'line2' => 'line2',
        'line3' => 'line3',
        'line4' => 'line4',
        'zipOrPostcode' => '33945'
    ],
    'challenge' => [
        'description' => 'challenge description',
        'value' => '11984567'
    ],
    'company' => [
        'name' => 'ABC Group Plc',
        'operatingName' => 'ABC Co',
        'taxId' => '123123123'
    ],
    'contactSmsNumber' => '11235555555',
    'email' => 'bob@example.com',
    'individual' => [
        'dateOfBirth' => '1985-01-01',
        'name' => [
                'firstName' => 'Bob',
                'lastName' => 'Smith',
                'otherNames' => 'A',
                'title' => 'Mr'
        ],
        'nationalIdentification' => 'AB123456C'
    ],
    'language' => 'en-US'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate', [
  'body' => '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => 'Key West',
    'country' => 'US',
    'countyOrProvince' => 'FL',
    'line1' => '500 Duval St',
    'line2' => 'line2',
    'line3' => 'line3',
    'line4' => 'line4',
    'zipOrPostcode' => '33945'
  ],
  'challenge' => [
    'description' => 'challenge description',
    'value' => '11984567'
  ],
  'company' => [
    'name' => 'ABC Group Plc',
    'operatingName' => 'ABC Co',
    'taxId' => '123123123'
  ],
  'contactSmsNumber' => '11235555555',
  'email' => 'bob@example.com',
  'individual' => [
    'dateOfBirth' => '1985-01-01',
    'name' => [
        'firstName' => 'Bob',
        'lastName' => 'Smith',
        'otherNames' => 'A',
        'title' => 'Mr'
    ],
    'nationalIdentification' => 'AB123456C'
  ],
  'language' => 'en-US'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'address' => [
    'city' => 'Key West',
    'country' => 'US',
    'countyOrProvince' => 'FL',
    'line1' => '500 Duval St',
    'line2' => 'line2',
    'line3' => 'line3',
    'line4' => 'line4',
    'zipOrPostcode' => '33945'
  ],
  'challenge' => [
    'description' => 'challenge description',
    'value' => '11984567'
  ],
  'company' => [
    'name' => 'ABC Group Plc',
    'operatingName' => 'ABC Co',
    'taxId' => '123123123'
  ],
  'contactSmsNumber' => '11235555555',
  'email' => 'bob@example.com',
  'individual' => [
    'dateOfBirth' => '1985-01-01',
    'name' => [
        'firstName' => 'Bob',
        'lastName' => 'Smith',
        'otherNames' => 'A',
        'title' => 'Mr'
    ],
    'nationalIdentification' => 'AB123456C'
  ],
  'language' => 'en-US'
]));
$request->setRequestUrl('{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v4/payees/:payeeId/payeeDetailsUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"

payload = {
    "address": {
        "city": "Key West",
        "country": "US",
        "countyOrProvince": "FL",
        "line1": "500 Duval St",
        "line2": "line2",
        "line3": "line3",
        "line4": "line4",
        "zipOrPostcode": "33945"
    },
    "challenge": {
        "description": "challenge description",
        "value": "11984567"
    },
    "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co",
        "taxId": "123123123"
    },
    "contactSmsNumber": "11235555555",
    "email": "bob@example.com",
    "individual": {
        "dateOfBirth": "1985-01-01",
        "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "A",
            "title": "Mr"
        },
        "nationalIdentification": "AB123456C"
    },
    "language": "en-US"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate"

payload <- "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v4/payees/:payeeId/payeeDetailsUpdate') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"11984567\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"contactSmsNumber\": \"11235555555\",\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate";

    let payload = json!({
        "address": json!({
            "city": "Key West",
            "country": "US",
            "countyOrProvince": "FL",
            "line1": "500 Duval St",
            "line2": "line2",
            "line3": "line3",
            "line4": "line4",
            "zipOrPostcode": "33945"
        }),
        "challenge": json!({
            "description": "challenge description",
            "value": "11984567"
        }),
        "company": json!({
            "name": "ABC Group Plc",
            "operatingName": "ABC Co",
            "taxId": "123123123"
        }),
        "contactSmsNumber": "11235555555",
        "email": "bob@example.com",
        "individual": json!({
            "dateOfBirth": "1985-01-01",
            "name": json!({
                "firstName": "Bob",
                "lastName": "Smith",
                "otherNames": "A",
                "title": "Mr"
            }),
            "nationalIdentification": "AB123456C"
        }),
        "language": "en-US"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate \
  --header 'content-type: application/json' \
  --data '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
echo '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "11984567"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}' |  \
  http POST {{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "Key West",\n    "country": "US",\n    "countyOrProvince": "FL",\n    "line1": "500 Duval St",\n    "line2": "line2",\n    "line3": "line3",\n    "line4": "line4",\n    "zipOrPostcode": "33945"\n  },\n  "challenge": {\n    "description": "challenge description",\n    "value": "11984567"\n  },\n  "company": {\n    "name": "ABC Group Plc",\n    "operatingName": "ABC Co",\n    "taxId": "123123123"\n  },\n  "contactSmsNumber": "11235555555",\n  "email": "bob@example.com",\n  "individual": {\n    "dateOfBirth": "1985-01-01",\n    "name": {\n      "firstName": "Bob",\n      "lastName": "Smith",\n      "otherNames": "A",\n      "title": "Mr"\n    },\n    "nationalIdentification": "AB123456C"\n  },\n  "language": "en-US"\n}' \
  --output-document \
  - {{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  ],
  "challenge": [
    "description": "challenge description",
    "value": "11984567"
  ],
  "company": [
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  ],
  "contactSmsNumber": "11235555555",
  "email": "bob@example.com",
  "individual": [
    "dateOfBirth": "1985-01-01",
    "name": [
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    ],
    "nationalIdentification": "AB123456C"
  ],
  "language": "en-US"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/:payeeId/payeeDetailsUpdate")! 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()
POST Update Payee Details
{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate
QUERY PARAMS

payeeId
BODY json

{
  "address": {
    "city": "",
    "country": "",
    "countyOrProvince": "",
    "line1": "",
    "line2": "",
    "line3": "",
    "line4": "",
    "zipOrPostcode": ""
  },
  "challenge": {
    "description": "",
    "value": ""
  },
  "company": {
    "name": "",
    "operatingName": "",
    "taxId": ""
  },
  "email": "",
  "individual": {
    "dateOfBirth": "",
    "name": "",
    "nationalIdentification": ""
  },
  "language": "",
  "payeeType": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate" {:content-type :json
                                                                                  :form-params {:address {:city "Key West"
                                                                                                          :country "US"
                                                                                                          :countyOrProvince "FL"
                                                                                                          :line1 "500 Duval St"
                                                                                                          :line2 "line2"
                                                                                                          :line3 "line3"
                                                                                                          :line4 "line4"
                                                                                                          :zipOrPostcode "33945"}
                                                                                                :challenge {:description "challenge description"
                                                                                                            :value "challenge test"}
                                                                                                :company {:name "ABC Group Plc"
                                                                                                          :operatingName "ABC Co"
                                                                                                          :taxId "123123123"}
                                                                                                :email "bob@example.com"
                                                                                                :individual {:dateOfBirth "1985-01-01"
                                                                                                             :name {:firstName "Bob"
                                                                                                                    :lastName "Smith"
                                                                                                                    :otherNames "A"
                                                                                                                    :title "Mr"}
                                                                                                             :nationalIdentification "AB123456C"}
                                                                                                :language "en-US"}})
require "http/client"

url = "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"),
    Content = new StringContent("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"

	payload := strings.NewReader("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")

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

	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))

}
POST /baseUrl/v3/payees/:payeeId/payeeDetailsUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 692

{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
  .asString();
const data = JSON.stringify({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {
    description: 'challenge description',
    value: 'challenge test'
  },
  company: {
    name: 'ABC Group Plc',
    operatingName: 'ABC Co',
    taxId: '123123123'
  },
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {
      firstName: 'Bob',
      lastName: 'Smith',
      otherNames: 'A',
      title: 'Mr'
    },
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: 'challenge test'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"Key West","country":"US","countyOrProvince":"FL","line1":"500 Duval St","line2":"line2","line3":"line3","line4":"line4","zipOrPostcode":"33945"},"challenge":{"description":"challenge description","value":"challenge test"},"company":{"name":"ABC Group Plc","operatingName":"ABC Co","taxId":"123123123"},"email":"bob@example.com","individual":{"dateOfBirth":"1985-01-01","name":{"firstName":"Bob","lastName":"Smith","otherNames":"A","title":"Mr"},"nationalIdentification":"AB123456C"},"language":"en-US"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": {\n    "city": "Key West",\n    "country": "US",\n    "countyOrProvince": "FL",\n    "line1": "500 Duval St",\n    "line2": "line2",\n    "line3": "line3",\n    "line4": "line4",\n    "zipOrPostcode": "33945"\n  },\n  "challenge": {\n    "description": "challenge description",\n    "value": "challenge test"\n  },\n  "company": {\n    "name": "ABC Group Plc",\n    "operatingName": "ABC Co",\n    "taxId": "123123123"\n  },\n  "email": "bob@example.com",\n  "individual": {\n    "dateOfBirth": "1985-01-01",\n    "name": {\n      "firstName": "Bob",\n      "lastName": "Smith",\n      "otherNames": "A",\n      "title": "Mr"\n    },\n    "nationalIdentification": "AB123456C"\n  },\n  "language": "en-US"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/:payeeId/payeeDetailsUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {description: 'challenge description', value: 'challenge test'},
  company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  body: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: 'challenge test'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  address: {
    city: 'Key West',
    country: 'US',
    countyOrProvince: 'FL',
    line1: '500 Duval St',
    line2: 'line2',
    line3: 'line3',
    line4: 'line4',
    zipOrPostcode: '33945'
  },
  challenge: {
    description: 'challenge description',
    value: 'challenge test'
  },
  company: {
    name: 'ABC Group Plc',
    operatingName: 'ABC Co',
    taxId: '123123123'
  },
  email: 'bob@example.com',
  individual: {
    dateOfBirth: '1985-01-01',
    name: {
      firstName: 'Bob',
      lastName: 'Smith',
      otherNames: 'A',
      title: 'Mr'
    },
    nationalIdentification: 'AB123456C'
  },
  language: 'en-US'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    address: {
      city: 'Key West',
      country: 'US',
      countyOrProvince: 'FL',
      line1: '500 Duval St',
      line2: 'line2',
      line3: 'line3',
      line4: 'line4',
      zipOrPostcode: '33945'
    },
    challenge: {description: 'challenge description', value: 'challenge test'},
    company: {name: 'ABC Group Plc', operatingName: 'ABC Co', taxId: '123123123'},
    email: 'bob@example.com',
    individual: {
      dateOfBirth: '1985-01-01',
      name: {firstName: 'Bob', lastName: 'Smith', otherNames: 'A', title: 'Mr'},
      nationalIdentification: 'AB123456C'
    },
    language: 'en-US'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"address":{"city":"Key West","country":"US","countyOrProvince":"FL","line1":"500 Duval St","line2":"line2","line3":"line3","line4":"line4","zipOrPostcode":"33945"},"challenge":{"description":"challenge description","value":"challenge test"},"company":{"name":"ABC Group Plc","operatingName":"ABC Co","taxId":"123123123"},"email":"bob@example.com","individual":{"dateOfBirth":"1985-01-01","name":{"firstName":"Bob","lastName":"Smith","otherNames":"A","title":"Mr"},"nationalIdentification":"AB123456C"},"language":"en-US"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"address": @{ @"city": @"Key West", @"country": @"US", @"countyOrProvince": @"FL", @"line1": @"500 Duval St", @"line2": @"line2", @"line3": @"line3", @"line4": @"line4", @"zipOrPostcode": @"33945" },
                              @"challenge": @{ @"description": @"challenge description", @"value": @"challenge test" },
                              @"company": @{ @"name": @"ABC Group Plc", @"operatingName": @"ABC Co", @"taxId": @"123123123" },
                              @"email": @"bob@example.com",
                              @"individual": @{ @"dateOfBirth": @"1985-01-01", @"name": @{ @"firstName": @"Bob", @"lastName": @"Smith", @"otherNames": @"A", @"title": @"Mr" }, @"nationalIdentification": @"AB123456C" },
                              @"language": @"en-US" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => [
        'city' => 'Key West',
        'country' => 'US',
        'countyOrProvince' => 'FL',
        'line1' => '500 Duval St',
        'line2' => 'line2',
        'line3' => 'line3',
        'line4' => 'line4',
        'zipOrPostcode' => '33945'
    ],
    'challenge' => [
        'description' => 'challenge description',
        'value' => 'challenge test'
    ],
    'company' => [
        'name' => 'ABC Group Plc',
        'operatingName' => 'ABC Co',
        'taxId' => '123123123'
    ],
    'email' => 'bob@example.com',
    'individual' => [
        'dateOfBirth' => '1985-01-01',
        'name' => [
                'firstName' => 'Bob',
                'lastName' => 'Smith',
                'otherNames' => 'A',
                'title' => 'Mr'
        ],
        'nationalIdentification' => 'AB123456C'
    ],
    'language' => 'en-US'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate', [
  'body' => '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => [
    'city' => 'Key West',
    'country' => 'US',
    'countyOrProvince' => 'FL',
    'line1' => '500 Duval St',
    'line2' => 'line2',
    'line3' => 'line3',
    'line4' => 'line4',
    'zipOrPostcode' => '33945'
  ],
  'challenge' => [
    'description' => 'challenge description',
    'value' => 'challenge test'
  ],
  'company' => [
    'name' => 'ABC Group Plc',
    'operatingName' => 'ABC Co',
    'taxId' => '123123123'
  ],
  'email' => 'bob@example.com',
  'individual' => [
    'dateOfBirth' => '1985-01-01',
    'name' => [
        'firstName' => 'Bob',
        'lastName' => 'Smith',
        'otherNames' => 'A',
        'title' => 'Mr'
    ],
    'nationalIdentification' => 'AB123456C'
  ],
  'language' => 'en-US'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'address' => [
    'city' => 'Key West',
    'country' => 'US',
    'countyOrProvince' => 'FL',
    'line1' => '500 Duval St',
    'line2' => 'line2',
    'line3' => 'line3',
    'line4' => 'line4',
    'zipOrPostcode' => '33945'
  ],
  'challenge' => [
    'description' => 'challenge description',
    'value' => 'challenge test'
  ],
  'company' => [
    'name' => 'ABC Group Plc',
    'operatingName' => 'ABC Co',
    'taxId' => '123123123'
  ],
  'email' => 'bob@example.com',
  'individual' => [
    'dateOfBirth' => '1985-01-01',
    'name' => [
        'firstName' => 'Bob',
        'lastName' => 'Smith',
        'otherNames' => 'A',
        'title' => 'Mr'
    ],
    'nationalIdentification' => 'AB123456C'
  ],
  'language' => 'en-US'
]));
$request->setRequestUrl('{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payees/:payeeId/payeeDetailsUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"

payload = {
    "address": {
        "city": "Key West",
        "country": "US",
        "countyOrProvince": "FL",
        "line1": "500 Duval St",
        "line2": "line2",
        "line3": "line3",
        "line4": "line4",
        "zipOrPostcode": "33945"
    },
    "challenge": {
        "description": "challenge description",
        "value": "challenge test"
    },
    "company": {
        "name": "ABC Group Plc",
        "operatingName": "ABC Co",
        "taxId": "123123123"
    },
    "email": "bob@example.com",
    "individual": {
        "dateOfBirth": "1985-01-01",
        "name": {
            "firstName": "Bob",
            "lastName": "Smith",
            "otherNames": "A",
            "title": "Mr"
        },
        "nationalIdentification": "AB123456C"
    },
    "language": "en-US"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate"

payload <- "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payees/:payeeId/payeeDetailsUpdate') do |req|
  req.body = "{\n  \"address\": {\n    \"city\": \"Key West\",\n    \"country\": \"US\",\n    \"countyOrProvince\": \"FL\",\n    \"line1\": \"500 Duval St\",\n    \"line2\": \"line2\",\n    \"line3\": \"line3\",\n    \"line4\": \"line4\",\n    \"zipOrPostcode\": \"33945\"\n  },\n  \"challenge\": {\n    \"description\": \"challenge description\",\n    \"value\": \"challenge test\"\n  },\n  \"company\": {\n    \"name\": \"ABC Group Plc\",\n    \"operatingName\": \"ABC Co\",\n    \"taxId\": \"123123123\"\n  },\n  \"email\": \"bob@example.com\",\n  \"individual\": {\n    \"dateOfBirth\": \"1985-01-01\",\n    \"name\": {\n      \"firstName\": \"Bob\",\n      \"lastName\": \"Smith\",\n      \"otherNames\": \"A\",\n      \"title\": \"Mr\"\n    },\n    \"nationalIdentification\": \"AB123456C\"\n  },\n  \"language\": \"en-US\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate";

    let payload = json!({
        "address": json!({
            "city": "Key West",
            "country": "US",
            "countyOrProvince": "FL",
            "line1": "500 Duval St",
            "line2": "line2",
            "line3": "line3",
            "line4": "line4",
            "zipOrPostcode": "33945"
        }),
        "challenge": json!({
            "description": "challenge description",
            "value": "challenge test"
        }),
        "company": json!({
            "name": "ABC Group Plc",
            "operatingName": "ABC Co",
            "taxId": "123123123"
        }),
        "email": "bob@example.com",
        "individual": json!({
            "dateOfBirth": "1985-01-01",
            "name": json!({
                "firstName": "Bob",
                "lastName": "Smith",
                "otherNames": "A",
                "title": "Mr"
            }),
            "nationalIdentification": "AB123456C"
        }),
        "language": "en-US"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate \
  --header 'content-type: application/json' \
  --data '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}'
echo '{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "challenge": {
    "description": "challenge description",
    "value": "challenge test"
  },
  "company": {
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  },
  "email": "bob@example.com",
  "individual": {
    "dateOfBirth": "1985-01-01",
    "name": {
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    },
    "nationalIdentification": "AB123456C"
  },
  "language": "en-US"
}' |  \
  http POST {{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": {\n    "city": "Key West",\n    "country": "US",\n    "countyOrProvince": "FL",\n    "line1": "500 Duval St",\n    "line2": "line2",\n    "line3": "line3",\n    "line4": "line4",\n    "zipOrPostcode": "33945"\n  },\n  "challenge": {\n    "description": "challenge description",\n    "value": "challenge test"\n  },\n  "company": {\n    "name": "ABC Group Plc",\n    "operatingName": "ABC Co",\n    "taxId": "123123123"\n  },\n  "email": "bob@example.com",\n  "individual": {\n    "dateOfBirth": "1985-01-01",\n    "name": {\n      "firstName": "Bob",\n      "lastName": "Smith",\n      "otherNames": "A",\n      "title": "Mr"\n    },\n    "nationalIdentification": "AB123456C"\n  },\n  "language": "en-US"\n}' \
  --output-document \
  - {{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": [
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  ],
  "challenge": [
    "description": "challenge description",
    "value": "challenge test"
  ],
  "company": [
    "name": "ABC Group Plc",
    "operatingName": "ABC Co",
    "taxId": "123123123"
  ],
  "email": "bob@example.com",
  "individual": [
    "dateOfBirth": "1985-01-01",
    "name": [
      "firstName": "Bob",
      "lastName": "Smith",
      "otherNames": "A",
      "title": "Mr"
    ],
    "nationalIdentification": "AB123456C"
  ],
  "language": "en-US"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/:payeeId/payeeDetailsUpdate")! 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()
POST Update Payee Remote Id (POST)
{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate
QUERY PARAMS

payeeId
BODY json

{
  "payorId": "",
  "remoteId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate" {:content-type :json
                                                                              :form-params {:payorId "9ac75325-5dcd-42d5-b992-175d7e0a035e"
                                                                                            :remoteId "remoteId123"}})
require "http/client"

url = "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"),
    Content = new StringContent("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"

	payload := strings.NewReader("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")

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

	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))

}
POST /baseUrl/v4/payees/:payeeId/remoteIdUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
  .asString();
const data = JSON.stringify({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  remoteId: 'remoteId123'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e","remoteId":"remoteId123"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",\n  "remoteId": "remoteId123"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payees/:payeeId/remoteIdUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  body: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  remoteId: 'remoteId123'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e","remoteId":"remoteId123"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payorId": @"9ac75325-5dcd-42d5-b992-175d7e0a035e",
                              @"remoteId": @"remoteId123" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
    'remoteId' => 'remoteId123'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate', [
  'body' => '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  'remoteId' => 'remoteId123'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  'remoteId' => 'remoteId123'
]));
$request->setRequestUrl('{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v4/payees/:payeeId/remoteIdUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"

payload = {
    "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
    "remoteId": "remoteId123"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate"

payload <- "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v4/payees/:payeeId/remoteIdUpdate') do |req|
  req.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate";

    let payload = json!({
        "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
        "remoteId": "remoteId123"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate \
  --header 'content-type: application/json' \
  --data '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
echo '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}' |  \
  http POST {{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",\n  "remoteId": "remoteId123"\n}' \
  --output-document \
  - {{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payees/:payeeId/remoteIdUpdate")! 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()
POST Update Payee Remote Id
{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate
QUERY PARAMS

payeeId
BODY json

{
  "payorId": "",
  "remoteId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate" {:content-type :json
                                                                              :form-params {:payorId "9ac75325-5dcd-42d5-b992-175d7e0a035e"
                                                                                            :remoteId "remoteId123"}})
require "http/client"

url = "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"),
    Content = new StringContent("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"

	payload := strings.NewReader("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")

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

	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))

}
POST /baseUrl/v3/payees/:payeeId/remoteIdUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
  .asString();
const data = JSON.stringify({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  remoteId: 'remoteId123'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e","remoteId":"remoteId123"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",\n  "remoteId": "remoteId123"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payees/:payeeId/remoteIdUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  body: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  remoteId: 'remoteId123'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate',
  headers: {'content-type': 'application/json'},
  data: {payorId: '9ac75325-5dcd-42d5-b992-175d7e0a035e', remoteId: 'remoteId123'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payorId":"9ac75325-5dcd-42d5-b992-175d7e0a035e","remoteId":"remoteId123"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payorId": @"9ac75325-5dcd-42d5-b992-175d7e0a035e",
                              @"remoteId": @"remoteId123" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
    'remoteId' => 'remoteId123'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate', [
  'body' => '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  'remoteId' => 'remoteId123'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payorId' => '9ac75325-5dcd-42d5-b992-175d7e0a035e',
  'remoteId' => 'remoteId123'
]));
$request->setRequestUrl('{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payees/:payeeId/remoteIdUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"

payload = {
    "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
    "remoteId": "remoteId123"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate"

payload <- "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payees/:payeeId/remoteIdUpdate') do |req|
  req.body = "{\n  \"payorId\": \"9ac75325-5dcd-42d5-b992-175d7e0a035e\",\n  \"remoteId\": \"remoteId123\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate";

    let payload = json!({
        "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
        "remoteId": "remoteId123"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate \
  --header 'content-type: application/json' \
  --data '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}'
echo '{
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
}' |  \
  http POST {{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",\n  "remoteId": "remoteId123"\n}' \
  --output-document \
  - {{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payorId": "9ac75325-5dcd-42d5-b992-175d7e0a035e",
  "remoteId": "remoteId123"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payees/:payeeId/remoteIdUpdate")! 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()
GET Export Transactions
{{baseUrl}}/v4/paymentaudit/transactions
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/transactions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/transactions")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/transactions"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/transactions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/transactions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/transactions"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/transactions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/transactions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/transactions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/transactions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/transactions")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/transactions');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/transactions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/transactions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/transactions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/transactions")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/transactions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/transactions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/transactions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/transactions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/transactions';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/transactions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/transactions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/transactions');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/transactions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/transactions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/transactions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/transactions' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/transactions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/transactions"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/transactions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/transactions")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/transactions') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/transactions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/transactions
http GET {{baseUrl}}/v4/paymentaudit/transactions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/transactions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/transactions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
GET Get Fundings for Payor
{{baseUrl}}/v4/paymentaudit/fundings
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/fundings?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/fundings" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/fundings?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/fundings?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/fundings?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/fundings?payorId="

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/fundings?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/fundings?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/fundings?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/fundings?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/fundings?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/fundings?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/fundings',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/fundings?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/fundings?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/fundings?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/fundings?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/fundings',
  qs: {payorId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/fundings');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/fundings',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/fundings?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/fundings?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/fundings?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/fundings?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/fundings?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/fundings');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/fundings');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/fundings?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/fundings?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/fundings?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/fundings"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/fundings"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/fundings?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/fundings') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/fundings";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v4/paymentaudit/fundings?payorId='
http GET '{{baseUrl}}/v4/paymentaudit/fundings?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v4/paymentaudit/fundings?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/fundings?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "amount": 120000,
      "currency": "USD",
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "events": [
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        },
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        }
      ],
      "fundingAccountName": "fundingAccountName",
      "fundingType": "fundingType",
      "sourceAccountName": "sourceAccountName",
      "status": "status",
      "topupType": "topupType"
    },
    {
      "amount": 120000,
      "currency": "USD",
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "events": [
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        },
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        }
      ],
      "fundingAccountName": "fundingAccountName",
      "fundingType": "fundingType",
      "sourceAccountName": "sourceAccountName",
      "status": "status",
      "topupType": "topupType"
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v1/paymentaudit/fundings?payorId=2a5d8af2-a1ed-4d7f-b9a7-ebe4b333be5a&page=1&pageSize=10",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v1/paymentaudit/fundings?payorId=2a5d8af2-a1ed-4d7f-b9a7-ebe4b333be5a&page=1&pageSize=10",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 33,
    "totalPages": 2
  }
}
GET Get List of Payments
{{baseUrl}}/v4/paymentaudit/payments
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/payments");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/payments")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/payments"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/payments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/payments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/payments"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/payments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/payments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/payments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payments")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/payments")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/payments');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/payments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/payments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payments")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/payments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payments'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/payments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/payments';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/payments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/payments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/payments');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/payments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/payments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/payments' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/payments' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/payments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/payments"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/payments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/payments")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/payments') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/payments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/payments
http GET {{baseUrl}}/v4/paymentaudit/payments
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/payments
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/payments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "autoWithdrawnReasonCode": "autoWithdrawnReasonCode",
      "countryCode": "US",
      "events": [
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        },
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 3.616076749251911,
      "isPaymentCcyBaseCcy": true,
      "payeeAddressCountryCode": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 7,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "EUR",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentMetadata": "sample metadata",
      "paymentScheme": "paymentScheme",
      "paymentTrackingReference": "paymentTrackingReference",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "payout": {
        "payoutFrom": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        },
        "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "payoutTo": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        }
      },
      "postInstructFxInfo": {
        "fxMode": "MANUAL",
        "fxStatus": "INITIATED",
        "fxStatusUpdatedAt": "2000-01-23T04:56:07.000+00:00",
        "fxTransactionReference": "AB123GHI"
      },
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 9.301444243932576,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "remoteSystemId": "REMOTE_SYSTEM_ID",
      "remoteSystemPaymentId": "remoteSystemPaymentId",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "EUR",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123",
      "transmissionType": "transmissionType",
      "withdrawable": true,
      "withdrawnReason": "withdrawnReason"
    },
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "autoWithdrawnReasonCode": "autoWithdrawnReasonCode",
      "countryCode": "US",
      "events": [
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        },
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 3.616076749251911,
      "isPaymentCcyBaseCcy": true,
      "payeeAddressCountryCode": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 7,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "EUR",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentMetadata": "sample metadata",
      "paymentScheme": "paymentScheme",
      "paymentTrackingReference": "paymentTrackingReference",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "payout": {
        "payoutFrom": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        },
        "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "payoutTo": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        }
      },
      "postInstructFxInfo": {
        "fxMode": "MANUAL",
        "fxStatus": "INITIATED",
        "fxStatusUpdatedAt": "2000-01-23T04:56:07.000+00:00",
        "fxTransactionReference": "AB123GHI"
      },
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 9.301444243932576,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "remoteSystemId": "REMOTE_SYSTEM_ID",
      "remoteSystemPaymentId": "remoteSystemPaymentId",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "EUR",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123",
      "transmissionType": "transmissionType",
      "withdrawable": true,
      "withdrawnReason": "withdrawnReason"
    }
  ],
  "links": [
    {
      "href": "https://example.com",
      "rel": "first"
    },
    {
      "href": "https://example.com",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 12,
    "totalPages": 12
  }
}
GET Get Payment
{{baseUrl}}/v4/paymentaudit/payments/:paymentId
QUERY PARAMS

paymentId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/payments/:paymentId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/payments/:paymentId")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/payments/:paymentId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/payments/:paymentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/payments/:paymentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/payments/:paymentId"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/payments/:paymentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/payments/:paymentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/payments/:paymentId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payments/:paymentId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/payments/:paymentId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/payments/:paymentId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/payments/:paymentId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/payments/:paymentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payments/:paymentId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/payments/:paymentId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payments/:paymentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/payments/:paymentId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/payments/:paymentId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/payments/:paymentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/payments/:paymentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/payments/:paymentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/payments/:paymentId');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/payments/:paymentId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/payments/:paymentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/payments/:paymentId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/payments/:paymentId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/payments/:paymentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/payments/:paymentId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/payments/:paymentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/payments/:paymentId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/payments/:paymentId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/payments/:paymentId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/payments/:paymentId
http GET {{baseUrl}}/v4/paymentaudit/payments/:paymentId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/payments/:paymentId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/payments/:paymentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "accountName": "My Account Name",
  "accountNumber": "123123232323",
  "autoWithdrawnReasonCode": "autoWithdrawnReasonCode",
  "countryCode": "US",
  "events": [
    {
      "accountName": "accountName",
      "accountNumber": "accountNumber",
      "eventDateTime": "2000-01-23T04:56:07.000+00:00",
      "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "eventType": "eventType",
      "iban": "iban",
      "paymentAmount": 1299,
      "paymentCurrency": "EUR",
      "principal": "principal",
      "routingNumber": "routingNumber",
      "scheduledAt": "2000-01-23T04:56:07.000+00:00",
      "scheduledBy": "Aphra Behn",
      "scheduledFor": "2000-01-23T04:56:07.000+00:00",
      "sourceAmount": 1299,
      "sourceCurrency": "EUR"
    },
    {
      "accountName": "accountName",
      "accountNumber": "accountNumber",
      "eventDateTime": "2000-01-23T04:56:07.000+00:00",
      "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "eventType": "eventType",
      "iban": "iban",
      "paymentAmount": 1299,
      "paymentCurrency": "EUR",
      "principal": "principal",
      "routingNumber": "routingNumber",
      "scheduledAt": "2000-01-23T04:56:07.000+00:00",
      "scheduledBy": "Aphra Behn",
      "scheduledFor": "2000-01-23T04:56:07.000+00:00",
      "sourceAmount": 1299,
      "sourceCurrency": "EUR"
    }
  ],
  "filenameReference": "file ref",
  "fundingStatus": "fundingStatus",
  "iban": "DE89 3704 0044 0532 0130 00",
  "individualIdentificationNumber": "1231231adf",
  "invertedRate": 3.616076749251911,
  "isPaymentCcyBaseCcy": true,
  "payeeAddressCountryCode": "US",
  "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "paymentAmount": 7,
  "paymentChannelId": "123asdf",
  "paymentChannelName": "My Payment Channel",
  "paymentCurrency": "EUR",
  "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "paymentMemo": "Payment memo",
  "paymentMetadata": "sample metadata",
  "paymentScheme": "paymentScheme",
  "paymentTrackingReference": "paymentTrackingReference",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "payorName": "payorName",
  "payorPaymentId": "123123asdf",
  "payout": {
    "payoutFrom": {
      "dbaName": "dbaName",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "payoutTo": {
      "dbaName": "dbaName",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    }
  },
  "postInstructFxInfo": {
    "fxMode": "MANUAL",
    "fxStatus": "INITIATED",
    "fxStatusUpdatedAt": "2000-01-23T04:56:07.000+00:00",
    "fxTransactionReference": "AB123GHI"
  },
  "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "railsBatchId": "railsBatchId",
  "railsId": "asdf123",
  "railsPaymentId": "railsPaymentId",
  "rate": 9.301444243932576,
  "rejectionReason": "rejectionReason",
  "remoteId": "aasdf123",
  "remoteSystemId": "REMOTE_SYSTEM_ID",
  "remoteSystemPaymentId": "remoteSystemPaymentId",
  "returnCost": 1232,
  "returnReason": "Some Reason Value",
  "routingNumber": "123123123123",
  "schedule": {
    "notificationsEnabled": true,
    "scheduleStatus": "SCHEDULED",
    "scheduledAt": "2000-01-23T04:56:07.000+00:00",
    "scheduledBy": "Aphra Behn",
    "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
    "scheduledFor": "2000-01-23T04:56:07.000+00:00"
  },
  "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "sourceAccountName": "My Account",
  "sourceAmount": 12345,
  "sourceCurrency": "EUR",
  "status": "status",
  "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
  "traceNumber": "abodu123",
  "transmissionType": "transmissionType",
  "withdrawable": true,
  "withdrawnReason": "withdrawnReason"
}
GET Get Payments for Payout
{{baseUrl}}/v4/paymentaudit/payouts/:payoutId
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/payouts/:payoutId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/payouts/:payoutId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/payouts/:payoutId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/payouts/:payoutId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/payouts/:payoutId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/payouts/:payoutId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/payouts/:payoutId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/payouts/:payoutId
http GET {{baseUrl}}/v4/paymentaudit/payouts/:payoutId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/payouts/:payoutId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/payouts/:payoutId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "autoWithdrawnReasonCode": "autoWithdrawnReasonCode",
      "countryCode": "US",
      "events": [
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        },
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 3.616076749251911,
      "isPaymentCcyBaseCcy": true,
      "payeeAddressCountryCode": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 7,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "EUR",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentMetadata": "sample metadata",
      "paymentScheme": "paymentScheme",
      "paymentTrackingReference": "paymentTrackingReference",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "payout": {
        "payoutFrom": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        },
        "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "payoutTo": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        }
      },
      "postInstructFxInfo": {
        "fxMode": "MANUAL",
        "fxStatus": "INITIATED",
        "fxStatusUpdatedAt": "2000-01-23T04:56:07.000+00:00",
        "fxTransactionReference": "AB123GHI"
      },
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 9.301444243932576,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "remoteSystemId": "REMOTE_SYSTEM_ID",
      "remoteSystemPaymentId": "remoteSystemPaymentId",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "EUR",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123",
      "transmissionType": "transmissionType",
      "withdrawable": true,
      "withdrawnReason": "withdrawnReason"
    },
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "autoWithdrawnReasonCode": "autoWithdrawnReasonCode",
      "countryCode": "US",
      "events": [
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        },
        {
          "accountName": "accountName",
          "accountNumber": "accountNumber",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "iban",
          "paymentAmount": 1299,
          "paymentCurrency": "EUR",
          "principal": "principal",
          "routingNumber": "routingNumber",
          "scheduledAt": "2000-01-23T04:56:07.000+00:00",
          "scheduledBy": "Aphra Behn",
          "scheduledFor": "2000-01-23T04:56:07.000+00:00",
          "sourceAmount": 1299,
          "sourceCurrency": "EUR"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 3.616076749251911,
      "isPaymentCcyBaseCcy": true,
      "payeeAddressCountryCode": "US",
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 7,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "EUR",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentMetadata": "sample metadata",
      "paymentScheme": "paymentScheme",
      "paymentTrackingReference": "paymentTrackingReference",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "payout": {
        "payoutFrom": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        },
        "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "payoutTo": {
          "dbaName": "dbaName",
          "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "payorName": "payorName",
          "principal": "principal",
          "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
        }
      },
      "postInstructFxInfo": {
        "fxMode": "MANUAL",
        "fxStatus": "INITIATED",
        "fxStatusUpdatedAt": "2000-01-23T04:56:07.000+00:00",
        "fxTransactionReference": "AB123GHI"
      },
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 9.301444243932576,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "remoteSystemId": "REMOTE_SYSTEM_ID",
      "remoteSystemPaymentId": "remoteSystemPaymentId",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "EUR",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123",
      "transmissionType": "transmissionType",
      "withdrawable": true,
      "withdrawnReason": "withdrawnReason"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  },
  "summary": {
    "confirmedPayments": 6,
    "incompletePayments": 5,
    "instructed": {
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "instructedDateTime": "2000-01-23T04:56:07.000+00:00",
    "payoutFrom": {
      "dbaName": "dbaName",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "payoutMemo": "payoutMemo",
    "payoutStatus": "payoutStatus",
    "payoutTo": {
      "dbaName": "dbaName",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "payoutType": "payoutType",
    "quoted": {
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "quotedDateTime": "2000-01-23T04:56:07.000+00:00",
    "releasedPayments": 1,
    "returnedPayments": 5,
    "schedule": {
      "notificationsEnabled": true,
      "scheduleStatus": "SCHEDULED",
      "scheduledAt": "2000-01-23T04:56:07.000+00:00",
      "scheduledBy": "Aphra Behn",
      "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
      "scheduledFor": "2000-01-23T04:56:07.000+00:00"
    },
    "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
    "submitting": {
      "dbaName": "dbaName",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "totalPayments": 0,
    "withdrawn": {
      "principal": "principal",
      "principalId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    "withdrawnDateTime": "2000-01-23T04:56:07.000+00:00",
    "withdrawnPayments": 2
  }
}
GET Get Payout Statistics
{{baseUrl}}/v4/paymentaudit/payoutStatistics
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/payoutStatistics");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/payoutStatistics")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/payoutStatistics"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/payoutStatistics"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/payoutStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/payoutStatistics"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/payoutStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/payoutStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/payoutStatistics"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payoutStatistics")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/payoutStatistics")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/payoutStatistics');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payoutStatistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/payoutStatistics';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/payoutStatistics',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payoutStatistics")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/payoutStatistics',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payoutStatistics'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/payoutStatistics');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/paymentaudit/payoutStatistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/payoutStatistics';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/payoutStatistics"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/payoutStatistics" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/payoutStatistics",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/payoutStatistics');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/payoutStatistics');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/payoutStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/payoutStatistics' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/payoutStatistics' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/payoutStatistics")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/payoutStatistics"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/payoutStatistics"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/payoutStatistics")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/payoutStatistics') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/payoutStatistics";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/payoutStatistics
http GET {{baseUrl}}/v4/paymentaudit/payoutStatistics
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/payoutStatistics
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/payoutStatistics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "thisMonthFailedPaymentsCount": 6,
  "thisMonthPayoutsCount": 0
}
GET Get Payouts for Payor
{{baseUrl}}/v4/paymentaudit/payouts
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/paymentaudit/payouts");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/paymentaudit/payouts")
require "http/client"

url = "{{baseUrl}}/v4/paymentaudit/payouts"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/paymentaudit/payouts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/paymentaudit/payouts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/paymentaudit/payouts"

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

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

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

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

}
GET /baseUrl/v4/paymentaudit/payouts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/paymentaudit/payouts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/paymentaudit/payouts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payouts")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/paymentaudit/payouts")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/paymentaudit/payouts');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payouts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/paymentaudit/payouts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/paymentaudit/payouts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/paymentaudit/payouts")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/paymentaudit/payouts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payouts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/paymentaudit/payouts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v4/paymentaudit/payouts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/paymentaudit/payouts';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/paymentaudit/payouts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/paymentaudit/payouts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/paymentaudit/payouts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/paymentaudit/payouts');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/paymentaudit/payouts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/paymentaudit/payouts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/paymentaudit/payouts' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/paymentaudit/payouts' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/paymentaudit/payouts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/paymentaudit/payouts"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/paymentaudit/payouts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/paymentaudit/payouts")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/paymentaudit/payouts') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/paymentaudit/payouts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v4/paymentaudit/payouts
http GET {{baseUrl}}/v4/paymentaudit/payouts
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v4/paymentaudit/payouts
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/paymentaudit/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "fxSummaries": [
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 123.23,
          "paymentCurrency": "EUR",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 123.23,
          "sourceCurrency": "EUR",
          "status": "status",
          "totalCost": 5,
          "totalPaymentAmount": 34235
        },
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 123.23,
          "paymentCurrency": "EUR",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 123.23,
          "sourceCurrency": "EUR",
          "status": "status",
          "totalCost": 5,
          "totalPaymentAmount": 34235
        }
      ],
      "instructedDateTime": "instructedDateTime",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutMemo": "payoutMemo",
      "payoutType": "payoutType",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountSummary": [
        {
          "currency": "EUR",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3344
        },
        {
          "currency": "EUR",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3344
        }
      ],
      "status": "status",
      "submittedDateTime": "submittedDateTime",
      "totalIncompletePayments": 6,
      "totalPayments": 0,
      "totalReturnedPayments": 1,
      "totalWithdrawnPayments": 5,
      "withdrawnDateTime": "2000-01-23T04:56:07.000+00:00"
    },
    {
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "fxSummaries": [
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 123.23,
          "paymentCurrency": "EUR",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 123.23,
          "sourceCurrency": "EUR",
          "status": "status",
          "totalCost": 5,
          "totalPaymentAmount": 34235
        },
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 123.23,
          "paymentCurrency": "EUR",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 123.23,
          "sourceCurrency": "EUR",
          "status": "status",
          "totalCost": 5,
          "totalPaymentAmount": 34235
        }
      ],
      "instructedDateTime": "instructedDateTime",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutMemo": "payoutMemo",
      "payoutType": "payoutType",
      "schedule": {
        "notificationsEnabled": true,
        "scheduleStatus": "SCHEDULED",
        "scheduledAt": "2000-01-23T04:56:07.000+00:00",
        "scheduledBy": "Aphra Behn",
        "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
        "scheduledFor": "2000-01-23T04:56:07.000+00:00"
      },
      "sourceAccountSummary": [
        {
          "currency": "EUR",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3344
        },
        {
          "currency": "EUR",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3344
        }
      ],
      "status": "status",
      "submittedDateTime": "submittedDateTime",
      "totalIncompletePayments": 6,
      "totalPayments": 0,
      "totalReturnedPayments": 1,
      "totalWithdrawnPayments": 5,
      "withdrawnDateTime": "2000-01-23T04:56:07.000+00:00"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
GET List Payment Changes
{{baseUrl}}/v4/payments/deltas
QUERY PARAMS

payorId
updatedSince
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v4/payments/deltas" {:query-params {:payorId ""
                                                                             :updatedSince ""}})
require "http/client"

url = "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince="

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

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

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

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

}
GET /baseUrl/v4/payments/deltas?payorId=&updatedSince= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payments/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v4/payments/deltas?payorId=&updatedSince=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payments/deltas',
  qs: {payorId: '', updatedSince: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v4/payments/deltas');

req.query({
  payorId: '',
  updatedSince: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v4/payments/deltas',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=');

echo $response->getBody();
setUrl('{{baseUrl}}/v4/payments/deltas');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => '',
  'updatedSince' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v4/payments/deltas');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => '',
  'updatedSince' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v4/payments/deltas?payorId=&updatedSince=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v4/payments/deltas"

querystring = {"payorId":"","updatedSince":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v4/payments/deltas"

queryString <- list(
  payorId = "",
  updatedSince = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v4/payments/deltas') do |req|
  req.params['payorId'] = ''
  req.params['updatedSince'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v4/payments/deltas";

    let querystring = [
        ("payorId", ""),
        ("updatedSince", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince='
http GET '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v4/payments/deltas?payorId=&updatedSince=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "paymentAmount": 0,
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorPaymentId": "payorPaymentId",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAmount": 6,
      "sourceCurrency": "sourceCurrency",
      "status": "status"
    },
    {
      "paymentAmount": 0,
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorPaymentId": "payorPaymentId",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAmount": 6,
      "sourceCurrency": "sourceCurrency",
      "status": "status"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
GET V1 Get Fundings for Payor
{{baseUrl}}/v1/paymentaudit/fundings
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/paymentaudit/fundings?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/paymentaudit/fundings" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v1/paymentaudit/fundings?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/paymentaudit/fundings?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/paymentaudit/fundings?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/paymentaudit/fundings?payorId="

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

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

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

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

}
GET /baseUrl/v1/paymentaudit/fundings?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/paymentaudit/fundings?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/paymentaudit/fundings?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/paymentaudit/fundings?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/paymentaudit/fundings?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/paymentaudit/fundings?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/fundings',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/paymentaudit/fundings?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/paymentaudit/fundings?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/paymentaudit/fundings?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/paymentaudit/fundings?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/fundings',
  qs: {payorId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/paymentaudit/fundings');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/fundings',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/paymentaudit/fundings?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/paymentaudit/fundings?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/paymentaudit/fundings?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/paymentaudit/fundings?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/paymentaudit/fundings?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/paymentaudit/fundings');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/paymentaudit/fundings');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/paymentaudit/fundings?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/paymentaudit/fundings?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/paymentaudit/fundings?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/paymentaudit/fundings"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/paymentaudit/fundings"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/paymentaudit/fundings?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/paymentaudit/fundings') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/paymentaudit/fundings";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/paymentaudit/fundings?payorId='
http GET '{{baseUrl}}/v1/paymentaudit/fundings?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/paymentaudit/fundings?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/paymentaudit/fundings?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "amount": 120000,
      "currency": "USD",
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "events": [
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        },
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        }
      ],
      "fundingAccountName": "fundingAccountName",
      "fundingType": "fundingType",
      "sourceAccountName": "sourceAccountName",
      "status": "status",
      "topupType": "topupType"
    },
    {
      "amount": 120000,
      "currency": "USD",
      "dateTime": "2000-01-23T04:56:07.000+00:00",
      "events": [
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        },
        {
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "fundingEventType": "fundingEventType",
          "principal": "principal"
        }
      ],
      "fundingAccountName": "fundingAccountName",
      "fundingType": "fundingType",
      "sourceAccountName": "sourceAccountName",
      "status": "status",
      "topupType": "topupType"
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v1/paymentaudit/fundings?payorId=2a5d8af2-a1ed-4d7f-b9a7-ebe4b333be5a&page=1&pageSize=10",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v1/paymentaudit/fundings?payorId=2a5d8af2-a1ed-4d7f-b9a7-ebe4b333be5a&page=1&pageSize=10",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 33,
    "totalPages": 2
  }
}
GET V1 Get Payout Statistics
{{baseUrl}}/v1/paymentaudit/payoutStatistics
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/paymentaudit/payoutStatistics");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/paymentaudit/payoutStatistics")
require "http/client"

url = "{{baseUrl}}/v1/paymentaudit/payoutStatistics"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/paymentaudit/payoutStatistics"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/paymentaudit/payoutStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/paymentaudit/payoutStatistics"

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

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

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

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

}
GET /baseUrl/v1/paymentaudit/payoutStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/paymentaudit/payoutStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/paymentaudit/payoutStatistics"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/paymentaudit/payoutStatistics")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/paymentaudit/payoutStatistics")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/paymentaudit/payoutStatistics');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/payoutStatistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/paymentaudit/payoutStatistics';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/paymentaudit/payoutStatistics',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/paymentaudit/payoutStatistics")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/paymentaudit/payoutStatistics',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/payoutStatistics'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/paymentaudit/payoutStatistics');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/paymentaudit/payoutStatistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/paymentaudit/payoutStatistics';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/paymentaudit/payoutStatistics"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/paymentaudit/payoutStatistics" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/paymentaudit/payoutStatistics",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/paymentaudit/payoutStatistics');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/paymentaudit/payoutStatistics');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/paymentaudit/payoutStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/paymentaudit/payoutStatistics' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/paymentaudit/payoutStatistics' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/paymentaudit/payoutStatistics")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/paymentaudit/payoutStatistics"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/paymentaudit/payoutStatistics"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/paymentaudit/payoutStatistics")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/paymentaudit/payoutStatistics') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/paymentaudit/payoutStatistics";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/paymentaudit/payoutStatistics
http GET {{baseUrl}}/v1/paymentaudit/payoutStatistics
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/paymentaudit/payoutStatistics
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/paymentaudit/payoutStatistics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "thisMonthFailedPaymentsCount": 6,
  "thisMonthPayoutsCount": 0
}
GET V1 List Payment Changes
{{baseUrl}}/v1/deltas/payments
QUERY PARAMS

payorId
updatedSince
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/deltas/payments" {:query-params {:payorId ""
                                                                             :updatedSince ""}})
require "http/client"

url = "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince="

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

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

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

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

}
GET /baseUrl/v1/deltas/payments?payorId=&updatedSince= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/payments',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deltas/payments?payorId=&updatedSince=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/payments',
  qs: {payorId: '', updatedSince: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/deltas/payments');

req.query({
  payorId: '',
  updatedSince: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/deltas/payments',
  params: {payorId: '', updatedSince: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/deltas/payments');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => '',
  'updatedSince' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/deltas/payments');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => '',
  'updatedSince' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/deltas/payments?payorId=&updatedSince=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/deltas/payments"

querystring = {"payorId":"","updatedSince":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/deltas/payments"

queryString <- list(
  payorId = "",
  updatedSince = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/deltas/payments') do |req|
  req.params['payorId'] = ''
  req.params['updatedSince'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deltas/payments";

    let querystring = [
        ("payorId", ""),
        ("updatedSince", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince='
http GET '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deltas/payments?payorId=&updatedSince=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "paymentAmount": 0,
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorPaymentId": "payorPaymentId",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAmount": 6,
      "sourceCurrency": "sourceCurrency",
      "status": "status"
    },
    {
      "paymentAmount": 0,
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorPaymentId": "payorPaymentId",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAmount": 6,
      "sourceCurrency": "sourceCurrency",
      "status": "status"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
GET V3 Export Transactions
{{baseUrl}}/v3/paymentaudit/transactions
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/paymentaudit/transactions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/paymentaudit/transactions")
require "http/client"

url = "{{baseUrl}}/v3/paymentaudit/transactions"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/paymentaudit/transactions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/paymentaudit/transactions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/paymentaudit/transactions"

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

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

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

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

}
GET /baseUrl/v3/paymentaudit/transactions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/paymentaudit/transactions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/paymentaudit/transactions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/transactions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/paymentaudit/transactions")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/paymentaudit/transactions');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/transactions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/paymentaudit/transactions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/paymentaudit/transactions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/transactions")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/paymentaudit/transactions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/transactions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/paymentaudit/transactions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/transactions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/paymentaudit/transactions';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/paymentaudit/transactions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/paymentaudit/transactions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/paymentaudit/transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/paymentaudit/transactions');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/paymentaudit/transactions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/paymentaudit/transactions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/paymentaudit/transactions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/paymentaudit/transactions' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/paymentaudit/transactions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/paymentaudit/transactions"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/paymentaudit/transactions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/paymentaudit/transactions")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/paymentaudit/transactions') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/paymentaudit/transactions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/paymentaudit/transactions
http GET {{baseUrl}}/v3/paymentaudit/transactions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/paymentaudit/transactions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/paymentaudit/transactions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/csv
RESPONSE BODY text

{
  "credit": 6,
  "creditCurrency": "creditCurrency",
  "dateFundingRequested": "dateFundingRequested",
  "debit": 0,
  "debitCurrency": "debitCurrency",
  "fundingType": "fundingType",
  "fxApplied": 5.962133916683182,
  "payeeType": "payeeType",
  "paymentAmount": 1,
  "paymentCurrency": "paymentCurrency",
  "paymentMemo": "paymentMemo",
  "paymentRails": "paymentRails",
  "paymentStatus": "paymentStatus",
  "payorPaymentId": "payorPaymentId",
  "rejectReason": "rejectReason",
  "remoteId": "remoteId",
  "reportTransactionType": "reportTransactionType",
  "returnCode": "returnCode",
  "returnDescription": "returnDescription",
  "returnFee": "returnFee",
  "returnFeeCurrency": "returnFeeCurrency",
  "returnFeeDescription": "returnFeeDescription",
  "sourceAccount": "sourceAccount",
  "transactionDate": "2000-01-23",
  "transactionTime": "transactionTime"
}
GET V3 Get List of Payments
{{baseUrl}}/v3/paymentaudit/payments
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/paymentaudit/payments");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/paymentaudit/payments")
require "http/client"

url = "{{baseUrl}}/v3/paymentaudit/payments"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/paymentaudit/payments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/paymentaudit/payments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/paymentaudit/payments"

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

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

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

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

}
GET /baseUrl/v3/paymentaudit/payments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/paymentaudit/payments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/paymentaudit/payments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payments")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/paymentaudit/payments")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/paymentaudit/payments');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/payments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/paymentaudit/payments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/paymentaudit/payments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payments")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/paymentaudit/payments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/payments'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/paymentaudit/payments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/paymentaudit/payments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/paymentaudit/payments';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/paymentaudit/payments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/paymentaudit/payments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/paymentaudit/payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/paymentaudit/payments');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/paymentaudit/payments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/paymentaudit/payments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/paymentaudit/payments' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/paymentaudit/payments' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/paymentaudit/payments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/paymentaudit/payments"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/paymentaudit/payments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/paymentaudit/payments")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/paymentaudit/payments') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/paymentaudit/payments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/paymentaudit/payments
http GET {{baseUrl}}/v3/paymentaudit/payments
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/paymentaudit/payments
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/paymentaudit/payments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "countryCode": "US",
      "events": [
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        },
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 1.4658129,
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 0,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentScheme": "paymentScheme",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 6.0274563,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "sourceCurrency",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123"
    },
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "countryCode": "US",
      "events": [
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        },
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 1.4658129,
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 0,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentScheme": "paymentScheme",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 6.0274563,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "sourceCurrency",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123"
    }
  ],
  "links": [
    {
      "href": "https://example.com",
      "rel": "first"
    },
    {
      "href": "https://example.com",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 12,
    "totalPages": 12
  }
}
GET V3 Get Payment
{{baseUrl}}/v3/paymentaudit/payments/:paymentId
QUERY PARAMS

paymentId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/paymentaudit/payments/:paymentId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/paymentaudit/payments/:paymentId")
require "http/client"

url = "{{baseUrl}}/v3/paymentaudit/payments/:paymentId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/paymentaudit/payments/:paymentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/paymentaudit/payments/:paymentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/paymentaudit/payments/:paymentId"

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

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

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

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

}
GET /baseUrl/v3/paymentaudit/payments/:paymentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/paymentaudit/payments/:paymentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/paymentaudit/payments/:paymentId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payments/:paymentId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/paymentaudit/payments/:paymentId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/paymentaudit/payments/:paymentId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/paymentaudit/payments/:paymentId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/paymentaudit/payments/:paymentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payments/:paymentId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/paymentaudit/payments/:paymentId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payments/:paymentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/paymentaudit/payments/:paymentId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payments/:paymentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/paymentaudit/payments/:paymentId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/paymentaudit/payments/:paymentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/paymentaudit/payments/:paymentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/paymentaudit/payments/:paymentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/paymentaudit/payments/:paymentId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/paymentaudit/payments/:paymentId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/paymentaudit/payments/:paymentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/paymentaudit/payments/:paymentId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/paymentaudit/payments/:paymentId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/paymentaudit/payments/:paymentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/paymentaudit/payments/:paymentId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/paymentaudit/payments/:paymentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/paymentaudit/payments/:paymentId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/paymentaudit/payments/:paymentId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/paymentaudit/payments/:paymentId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/paymentaudit/payments/:paymentId
http GET {{baseUrl}}/v3/paymentaudit/payments/:paymentId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/paymentaudit/payments/:paymentId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/paymentaudit/payments/:paymentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "accountName": "My Account Name",
  "accountNumber": "123123232323",
  "countryCode": "US",
  "events": [
    {
      "accountName": "My account",
      "accountNumber": "123123123",
      "eventDateTime": "2000-01-23T04:56:07.000+00:00",
      "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "eventType": "eventType",
      "iban": "DE89 3704 0044 0532 0130 00",
      "paymentAmount": 1299,
      "paymentCurrency": "paymentCurrency",
      "principal": "Prinicple example",
      "routingNumber": "123123123",
      "sourceAmount": 1299,
      "sourceCurrency": "sourceCurrency"
    },
    {
      "accountName": "My account",
      "accountNumber": "123123123",
      "eventDateTime": "2000-01-23T04:56:07.000+00:00",
      "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "eventType": "eventType",
      "iban": "DE89 3704 0044 0532 0130 00",
      "paymentAmount": 1299,
      "paymentCurrency": "paymentCurrency",
      "principal": "Prinicple example",
      "routingNumber": "123123123",
      "sourceAmount": 1299,
      "sourceCurrency": "sourceCurrency"
    }
  ],
  "filenameReference": "file ref",
  "fundingStatus": "fundingStatus",
  "iban": "DE89 3704 0044 0532 0130 00",
  "individualIdentificationNumber": "1231231adf",
  "invertedRate": 1.4658129,
  "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "paymentAmount": 0,
  "paymentChannelId": "123asdf",
  "paymentChannelName": "My Payment Channel",
  "paymentCurrency": "paymentCurrency",
  "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "paymentMemo": "Payment memo",
  "paymentScheme": "paymentScheme",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "payorName": "payorName",
  "payorPaymentId": "123123asdf",
  "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "railsBatchId": "railsBatchId",
  "railsId": "asdf123",
  "railsPaymentId": "railsPaymentId",
  "rate": 6.0274563,
  "rejectionReason": "rejectionReason",
  "remoteId": "aasdf123",
  "returnCost": 1232,
  "returnReason": "Some Reason Value",
  "routingNumber": "123123123123",
  "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "sourceAccountName": "My Account",
  "sourceAmount": 12345,
  "sourceCurrency": "sourceCurrency",
  "status": "status",
  "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
  "traceNumber": "abodu123"
}
GET V3 Get Payments for Payout
{{baseUrl}}/v3/paymentaudit/payouts/:payoutId
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")
require "http/client"

url = "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"

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

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

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

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

}
GET /baseUrl/v3/paymentaudit/payouts/:payoutId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/paymentaudit/payouts/:payoutId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/paymentaudit/payouts/:payoutId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/paymentaudit/payouts/:payoutId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/paymentaudit/payouts/:payoutId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/paymentaudit/payouts/:payoutId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/paymentaudit/payouts/:payoutId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/paymentaudit/payouts/:payoutId
http GET {{baseUrl}}/v3/paymentaudit/payouts/:payoutId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/paymentaudit/payouts/:payoutId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/paymentaudit/payouts/:payoutId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "countryCode": "US",
      "events": [
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        },
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 1.4658129,
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 0,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentScheme": "paymentScheme",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 6.0274563,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "sourceCurrency",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123"
    },
    {
      "accountName": "My Account Name",
      "accountNumber": "123123232323",
      "countryCode": "US",
      "events": [
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        },
        {
          "accountName": "My account",
          "accountNumber": "123123123",
          "eventDateTime": "2000-01-23T04:56:07.000+00:00",
          "eventId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "eventType": "eventType",
          "iban": "DE89 3704 0044 0532 0130 00",
          "paymentAmount": 1299,
          "paymentCurrency": "paymentCurrency",
          "principal": "Prinicple example",
          "routingNumber": "123123123",
          "sourceAmount": 1299,
          "sourceCurrency": "sourceCurrency"
        }
      ],
      "filenameReference": "file ref",
      "fundingStatus": "fundingStatus",
      "iban": "DE89 3704 0044 0532 0130 00",
      "individualIdentificationNumber": "1231231adf",
      "invertedRate": 1.4658129,
      "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentAmount": 0,
      "paymentChannelId": "123asdf",
      "paymentChannelName": "My Payment Channel",
      "paymentCurrency": "paymentCurrency",
      "paymentId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "paymentMemo": "Payment memo",
      "paymentScheme": "paymentScheme",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "payorPaymentId": "123123asdf",
      "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "railsBatchId": "railsBatchId",
      "railsId": "asdf123",
      "railsPaymentId": "railsPaymentId",
      "rate": 6.0274563,
      "rejectionReason": "rejectionReason",
      "remoteId": "aasdf123",
      "returnCost": 1232,
      "returnReason": "Some Reason Value",
      "routingNumber": "123123123123",
      "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "sourceAccountName": "My Account",
      "sourceAmount": 12345,
      "sourceCurrency": "sourceCurrency",
      "status": "status",
      "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
      "traceNumber": "abodu123"
    }
  ],
  "links": [
    {
      "href": "https://example.com",
      "rel": "first"
    },
    {
      "href": "https://example.com",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 12,
    "totalPages": 10
  },
  "summary": {
    "confirmedPayments": 123,
    "failedPayments": 0,
    "incompletePayments": 123,
    "instructedDateTime": "2000-01-23T04:56:07.000+00:00",
    "payoutMemo": "Payment Memo value",
    "payoutStatus": "payoutStatus",
    "releasedPayments": 123,
    "submittedDateTime": "2000-01-23T04:56:07.000+00:00",
    "totalPayments": 123,
    "withdrawnDateTime": "2000-01-23T04:56:07.000+00:00"
  }
}
GET V3 Get Payouts for Payor
{{baseUrl}}/v3/paymentaudit/payouts
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/paymentaudit/payouts?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/paymentaudit/payouts" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v3/paymentaudit/payouts?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/paymentaudit/payouts?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/paymentaudit/payouts?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/paymentaudit/payouts?payorId="

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

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

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

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

}
GET /baseUrl/v3/paymentaudit/payouts?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/paymentaudit/payouts?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/paymentaudit/payouts?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payouts?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/paymentaudit/payouts?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/paymentaudit/payouts?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/paymentaudit/payouts?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/paymentaudit/payouts?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/paymentaudit/payouts?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/paymentaudit/payouts?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts',
  qs: {payorId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/paymentaudit/payouts');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/paymentaudit/payouts',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/paymentaudit/payouts?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/paymentaudit/payouts?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/paymentaudit/payouts?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/paymentaudit/payouts?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/paymentaudit/payouts?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/paymentaudit/payouts');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/paymentaudit/payouts');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/paymentaudit/payouts?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/paymentaudit/payouts?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/paymentaudit/payouts?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/paymentaudit/payouts"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/paymentaudit/payouts"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/paymentaudit/payouts?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/paymentaudit/payouts') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/paymentaudit/payouts";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v3/paymentaudit/payouts?payorId='
http GET '{{baseUrl}}/v3/paymentaudit/payouts?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/paymentaudit/payouts?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/paymentaudit/payouts?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "fxSummaries": [
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 1.12,
          "paymentCurrency": "paymentCurrency",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 1.12,
          "sourceCurrency": "sourceCurrency",
          "status": "status",
          "totalCost": 1234,
          "totalPaymentAmount": 1234
        },
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 1.12,
          "paymentCurrency": "paymentCurrency",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 1.12,
          "sourceCurrency": "sourceCurrency",
          "status": "status",
          "totalCost": 1234,
          "totalPaymentAmount": 1234
        }
      ],
      "instructedDateTime": "instructedDateTime",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutMemo": "payoutMemo",
      "sourceAccountSummary": [
        {
          "currency": "currency",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3434
        },
        {
          "currency": "currency",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3434
        }
      ],
      "status": "status",
      "submittedDateTime": "submittedDateTime",
      "totalFailedPayments": 123,
      "totalIncompletePayments": 123,
      "totalPayments": 123,
      "withdrawnDateTime": "withdrawnDateTime"
    },
    {
      "fxSummaries": [
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 1.12,
          "paymentCurrency": "paymentCurrency",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 1.12,
          "sourceCurrency": "sourceCurrency",
          "status": "status",
          "totalCost": 1234,
          "totalPaymentAmount": 1234
        },
        {
          "creationDateTime": "2000-01-23T04:56:07.000+00:00",
          "fundingStatus": "fundingStatus",
          "invertedRate": 1.12,
          "paymentCurrency": "paymentCurrency",
          "quoteId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "rate": 1.12,
          "sourceCurrency": "sourceCurrency",
          "status": "status",
          "totalCost": 1234,
          "totalPaymentAmount": 1234
        }
      ],
      "instructedDateTime": "instructedDateTime",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payoutMemo": "payoutMemo",
      "sourceAccountSummary": [
        {
          "currency": "currency",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3434
        },
        {
          "currency": "currency",
          "sourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
          "totalCost": 3434
        }
      ],
      "status": "status",
      "submittedDateTime": "submittedDateTime",
      "totalFailedPayments": 123,
      "totalIncompletePayments": 123,
      "totalPayments": 123,
      "withdrawnDateTime": "withdrawnDateTime"
    }
  ],
  "links": [
    {
      "href": "https://example.com",
      "rel": "first"
    },
    {
      "href": "https://example.com",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 123,
    "totalPages": 123
  }
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payorLinks");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/payorLinks")
require "http/client"

url = "{{baseUrl}}/v1/payorLinks"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/payorLinks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payorLinks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payorLinks"

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

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

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

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

}
GET /baseUrl/v1/payorLinks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/payorLinks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payorLinks"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payorLinks")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/payorLinks")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/payorLinks');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/payorLinks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payorLinks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payorLinks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/payorLinks")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payorLinks',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/payorLinks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/payorLinks');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/payorLinks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payorLinks';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payorLinks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payorLinks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payorLinks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/payorLinks');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payorLinks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/payorLinks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payorLinks' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payorLinks' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/payorLinks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payorLinks"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payorLinks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payorLinks")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/payorLinks') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payorLinks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/payorLinks
http GET {{baseUrl}}/v1/payorLinks
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/payorLinks
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payorLinks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "links": [
    {
      "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "linkId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "linkType": "linkType",
      "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    },
    {
      "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "linkId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "linkType": "linkType",
      "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    }
  ],
  "payors": [
    {
      "kycState": "kycState",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "primaryContactEmail": "primaryContactEmail"
    },
    {
      "kycState": "kycState",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorName": "payorName",
      "primaryContactEmail": "primaryContactEmail"
    }
  ]
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId/branding/logos");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payors/:payorId/branding/logos" {:multipart [{:name "logo"
                                                                                           :content ""}]})
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId/branding/logos"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId/branding/logos"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "logo",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId/branding/logos");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId/branding/logos"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}
POST /baseUrl/v1/payors/:payorId/branding/logos HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 113

-----011000010111000001101001
Content-Disposition: form-data; name="logo"


-----011000010111000001101001--
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payors/:payorId/branding/logos")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId/branding/logos"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/branding/logos")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payors/:payorId/branding/logos")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('logo', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payors/:payorId/branding/logos');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('logo', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/branding/logos',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId/branding/logos';
const form = new FormData();
form.append('logo', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('logo', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId/branding/logos',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/branding/logos")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId/branding/logos',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write('-----011000010111000001101001\r\nContent-Disposition: form-data; name="logo"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/branding/logos',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {logo: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payors/:payorId/branding/logos');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/branding/logos',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="logo"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('logo', '');

const url = '{{baseUrl}}/v1/payors/:payorId/branding/logos';
const options = {method: 'POST'};
options.body = formData;

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

NSDictionary *headers = @{ @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"logo", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId/branding/logos"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId/branding/logos" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId/branding/logos",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payors/:payorId/branding/logos', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId/branding/logos');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="logo"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/v1/payors/:payorId/branding/logos');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId/branding/logos' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="logo"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId/branding/logos' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="logo"


-----011000010111000001101001--
'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/v1/payors/:payorId/branding/logos", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId/branding/logos"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId/branding/logos"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId/branding/logos")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/v1/payors/:payorId/branding/logos') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"logo\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId/branding/logos";

    let form = reqwest::multipart::Form::new()
        .text("logo", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payors/:payorId/branding/logos \
  --header 'content-type: multipart/form-data' \
  --form logo=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="logo"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/v1/payors/:payorId/branding/logos \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="logo"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId/branding/logos
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "logo",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId/branding/logos")! 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()
POST Create API Key
{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys
QUERY PARAMS

payorId
applicationId
BODY json

{
  "description": "",
  "name": "",
  "roles": []
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys" {:content-type :json
                                                                                                :form-params {:description ""
                                                                                                              :name ""
                                                                                                              :roles []}})
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}")

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

	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))

}
POST /baseUrl/v1/payors/:payorId/applications/:applicationId/keys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "description": "",
  "name": "",
  "roles": []
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}")
  .asString();
const data = JSON.stringify({
  description: '',
  name: '',
  roles: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys',
  headers: {'content-type': 'application/json'},
  data: {description: '', name: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","name":"","roles":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "name": "",\n  "roles": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId/applications/:applicationId/keys',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({description: '', name: '', roles: []}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys',
  headers: {'content-type': 'application/json'},
  body: {description: '', name: '', roles: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  name: '',
  roles: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys',
  headers: {'content-type': 'application/json'},
  data: {description: '', name: '', roles: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","name":"","roles":[]}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"name": @"",
                              @"roles": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => '',
    'name' => '',
    'roles' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys', [
  'body' => '{
  "description": "",
  "name": "",
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'name' => '',
  'roles' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'description' => '',
  'name' => '',
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "name": "",
  "roles": []
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "name": "",
  "roles": []
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/payors/:payorId/applications/:applicationId/keys", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"

payload = {
    "description": "",
    "name": "",
    "roles": []
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys"

payload <- "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/payors/:payorId/applications/:applicationId/keys') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"roles\": []\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys";

    let payload = json!({
        "description": "",
        "name": "",
        "roles": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "name": "",
  "roles": []
}'
echo '{
  "description": "",
  "name": "",
  "roles": []
}' |  \
  http POST {{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "name": "",\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "name": "",
  "roles": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId/applications/:applicationId/keys")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "apiKey": "385d4506-e7dd-446e-a092-5f30b98e7b26",
  "apiSecret": "f25767d9-342a-48ac-a788-0a7a38ae6fb3"
}
POST Create Application
{{baseUrl}}/v1/payors/:payorId/applications
QUERY PARAMS

payorId
BODY json

{
  "description": "",
  "name": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId/applications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payors/:payorId/applications" {:content-type :json
                                                                            :form-params {:description "SAP Application integration"
                                                                                          :name "SAP"}})
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId/applications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId/applications"),
    Content = new StringContent("{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId/applications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId/applications"

	payload := strings.NewReader("{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}")

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

	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))

}
POST /baseUrl/v1/payors/:payorId/applications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "description": "SAP Application integration",
  "name": "SAP"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payors/:payorId/applications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId/applications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/applications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payors/:payorId/applications")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}")
  .asString();
const data = JSON.stringify({
  description: 'SAP Application integration',
  name: 'SAP'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payors/:payorId/applications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications',
  headers: {'content-type': 'application/json'},
  data: {description: 'SAP Application integration', name: 'SAP'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId/applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"SAP Application integration","name":"SAP"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId/applications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "SAP Application integration",\n  "name": "SAP"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/applications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId/applications',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({description: 'SAP Application integration', name: 'SAP'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications',
  headers: {'content-type': 'application/json'},
  body: {description: 'SAP Application integration', name: 'SAP'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payors/:payorId/applications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: 'SAP Application integration',
  name: 'SAP'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/applications',
  headers: {'content-type': 'application/json'},
  data: {description: 'SAP Application integration', name: 'SAP'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payors/:payorId/applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"SAP Application integration","name":"SAP"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"SAP Application integration",
                              @"name": @"SAP" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId/applications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId/applications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId/applications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => 'SAP Application integration',
    'name' => 'SAP'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payors/:payorId/applications', [
  'body' => '{
  "description": "SAP Application integration",
  "name": "SAP"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId/applications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => 'SAP Application integration',
  'name' => 'SAP'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'description' => 'SAP Application integration',
  'name' => 'SAP'
]));
$request->setRequestUrl('{{baseUrl}}/v1/payors/:payorId/applications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId/applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "SAP Application integration",
  "name": "SAP"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId/applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "SAP Application integration",
  "name": "SAP"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/payors/:payorId/applications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId/applications"

payload = {
    "description": "SAP Application integration",
    "name": "SAP"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId/applications"

payload <- "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId/applications")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/payors/:payorId/applications') do |req|
  req.body = "{\n  \"description\": \"SAP Application integration\",\n  \"name\": \"SAP\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId/applications";

    let payload = json!({
        "description": "SAP Application integration",
        "name": "SAP"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payors/:payorId/applications \
  --header 'content-type: application/json' \
  --data '{
  "description": "SAP Application integration",
  "name": "SAP"
}'
echo '{
  "description": "SAP Application integration",
  "name": "SAP"
}' |  \
  http POST {{baseUrl}}/v1/payors/:payorId/applications \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "SAP Application integration",\n  "name": "SAP"\n}' \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId/applications
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "SAP Application integration",
  "name": "SAP"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId/applications")! 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()
GET Get Branding
{{baseUrl}}/v1/payors/:payorId/branding
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId/branding");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/payors/:payorId/branding")
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId/branding"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId/branding"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId/branding");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId/branding"

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

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

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

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

}
GET /baseUrl/v1/payors/:payorId/branding HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/payors/:payorId/branding")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId/branding"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/branding")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/payors/:payorId/branding")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/payors/:payorId/branding');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId/branding'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId/branding';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId/branding',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/branding")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId/branding',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId/branding'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/payors/:payorId/branding');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId/branding'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payors/:payorId/branding';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId/branding"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId/branding" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId/branding",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/payors/:payorId/branding');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId/branding');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/payors/:payorId/branding');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId/branding' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId/branding' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/payors/:payorId/branding")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId/branding"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId/branding"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId/branding")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/payors/:payorId/branding') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId/branding";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/payors/:payorId/branding
http GET {{baseUrl}}/v1/payors/:payorId/branding
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId/branding
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId/branding")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "collectiveAlias": "Contractors",
  "dbaName": "Key West Imports",
  "logoUrl": "https://images.example.com/450ecb66-df18-4d0c-b557-f718782775df/logo.png",
  "payorName": "Key West Imports, Inc",
  "supportContact": "support@example.com"
}
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "correlationId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "httpStatusCode": 400
}
GET Get Payor (GET)
{{baseUrl}}/v2/payors/:payorId
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/payors/:payorId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/payors/:payorId")
require "http/client"

url = "{{baseUrl}}/v2/payors/:payorId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/payors/:payorId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/payors/:payorId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/payors/:payorId"

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

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

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

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

}
GET /baseUrl/v2/payors/:payorId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/payors/:payorId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/payors/:payorId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/payors/:payorId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/payors/:payorId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/payors/:payorId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/payors/:payorId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/payors/:payorId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/payors/:payorId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/payors/:payorId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/payors/:payorId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/payors/:payorId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/payors/:payorId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/payors/:payorId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/payors/:payorId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/payors/:payorId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/payors/:payorId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/payors/:payorId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/payors/:payorId');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/payors/:payorId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/payors/:payorId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/payors/:payorId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/payors/:payorId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/payors/:payorId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/payors/:payorId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/payors/:payorId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/payors/:payorId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/payors/:payorId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/payors/:payorId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/payors/:payorId
http GET {{baseUrl}}/v2/payors/:payorId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/payors/:payorId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/payors/:payorId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "allowsLanguageChoice": true,
  "collectiveAlias": "Payee",
  "dbaName": "Some Biz",
  "includesReports": true,
  "kycState": "PASSED_KYC",
  "language": "EN",
  "managingPayees": true,
  "manualLockout": true,
  "maxMasterPayorAdmins": 6,
  "openBankingEnabled": true,
  "payeeGracePeriodDays": 0,
  "payeeGracePeriodProcessingEnabled": true,
  "paymentRails": "paymentRails",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "payorName": "Example, Corp",
  "payorXid": "ABC_201234",
  "primaryContactEmail": "joe.buck@example.com",
  "primaryContactName": "Joe Buck",
  "primaryContactPhone": "123-123-1234",
  "provider": "provider",
  "reminderEmailsOptOut": true,
  "remoteSystemIds": [
    "REMOTE_SYSTEM_ID",
    "REMOTE_SYSTEM_ID"
  ],
  "supportContact": "support@example.com",
  "transmissionTypes": {
    "ACH": true,
    "SAME_DAY_ACH": true,
    "WIRE": true
  },
  "usdTxnValueReportingThreshold": 1000000,
  "wuCustomerId": "wuCustomerId"
}
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "correlationId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "httpStatusCode": 400
}
GET Get Payor
{{baseUrl}}/v1/payors/:payorId
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/payors/:payorId")
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId"

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

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

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

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

}
GET /baseUrl/v1/payors/:payorId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/payors/:payorId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/payors/:payorId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/payors/:payorId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/payors/:payorId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/payors/:payorId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payors/:payorId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/payors/:payorId');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/payors/:payorId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/payors/:payorId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/payors/:payorId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/payors/:payorId
http GET {{baseUrl}}/v1/payors/:payorId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "address": {
    "city": "Key West",
    "country": "US",
    "countyOrProvince": "FL",
    "line1": "500 Duval St",
    "line2": "line2",
    "line3": "line3",
    "line4": "line4",
    "zipOrPostcode": "33945"
  },
  "allowsLanguageChoice": true,
  "collectiveAlias": "Payee",
  "dbaName": "Some Biz",
  "fundingAccountAccountName": "Example Corp BOA",
  "fundingAccountAccountNumber": "1234567890123",
  "fundingAccountRoutingNumber": "123456789",
  "includesReports": true,
  "kycState": "PASSED_KYC",
  "language": "EN",
  "manualLockout": true,
  "maxMasterPayorAdmins": 6,
  "payeeGracePeriodDays": 0,
  "payeeGracePeriodProcessingEnabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "payorName": "Example, Corp",
  "primaryContactEmail": "joe.buck@example.com",
  "primaryContactName": "Joe Buck",
  "primaryContactPhone": "123-123-1234",
  "reminderEmailsOptOut": true,
  "supportContact": "support@example.com",
  "transmissionTypes": {
    "ACH": true,
    "SAME_DAY_ACH": true,
    "WIRE": true
  }
}
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "correlationId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "httpStatusCode": 400
}
POST Reminder Email Opt-Out
{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate
QUERY PARAMS

payorId
BODY json

{
  "reminderEmailsOptOut": false
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"reminderEmailsOptOut\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate" {:content-type :json
                                                                                    :form-params {:reminderEmailsOptOut false}})
require "http/client"

url = "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reminderEmailsOptOut\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"),
    Content = new StringContent("{\n  \"reminderEmailsOptOut\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reminderEmailsOptOut\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"

	payload := strings.NewReader("{\n  \"reminderEmailsOptOut\": false\n}")

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

	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))

}
POST /baseUrl/v1/payors/:payorId/reminderEmailsUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "reminderEmailsOptOut": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reminderEmailsOptOut\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"reminderEmailsOptOut\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"reminderEmailsOptOut\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"reminderEmailsOptOut\": false\n}")
  .asString();
const data = JSON.stringify({
  reminderEmailsOptOut: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {reminderEmailsOptOut: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reminderEmailsOptOut":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reminderEmailsOptOut": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reminderEmailsOptOut\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payors/:payorId/reminderEmailsUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({reminderEmailsOptOut: false}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate',
  headers: {'content-type': 'application/json'},
  body: {reminderEmailsOptOut: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  reminderEmailsOptOut: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {reminderEmailsOptOut: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reminderEmailsOptOut":false}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reminderEmailsOptOut": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reminderEmailsOptOut\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'reminderEmailsOptOut' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate', [
  'body' => '{
  "reminderEmailsOptOut": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reminderEmailsOptOut' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'reminderEmailsOptOut' => null
]));
$request->setRequestUrl('{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reminderEmailsOptOut": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reminderEmailsOptOut": false
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reminderEmailsOptOut\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/payors/:payorId/reminderEmailsUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"

payload = { "reminderEmailsOptOut": False }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate"

payload <- "{\n  \"reminderEmailsOptOut\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reminderEmailsOptOut\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/payors/:payorId/reminderEmailsUpdate') do |req|
  req.body = "{\n  \"reminderEmailsOptOut\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate";

    let payload = json!({"reminderEmailsOptOut": false});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate \
  --header 'content-type: application/json' \
  --data '{
  "reminderEmailsOptOut": false
}'
echo '{
  "reminderEmailsOptOut": false
}' |  \
  http POST {{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "reminderEmailsOptOut": false\n}' \
  --output-document \
  - {{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["reminderEmailsOptOut": false] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payors/:payorId/reminderEmailsUpdate")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "correlationId": "ee53e01d-c078-43fd-abd4-47e92f4a06cf",
  "httpStatusCode": 400
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payorLinks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payorLinks" {:content-type :json
                                                          :form-params {:fromPayorId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
                                                                        :linkType "PARENT_OF"
                                                                        :toPayorId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"}})
require "http/client"

url = "{{baseUrl}}/v1/payorLinks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payorLinks"),
    Content = new StringContent("{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payorLinks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payorLinks"

	payload := strings.NewReader("{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")

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

	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))

}
POST /baseUrl/v1/payorLinks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payorLinks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payorLinks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payorLinks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payorLinks")
  .header("content-type", "application/json")
  .body("{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .asString();
const data = JSON.stringify({
  fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  linkType: 'PARENT_OF',
  toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payorLinks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payorLinks',
  headers: {'content-type': 'application/json'},
  data: {
    fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    linkType: 'PARENT_OF',
    toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payorLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fromPayorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91","linkType":"PARENT_OF","toPayorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payorLinks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",\n  "linkType": "PARENT_OF",\n  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payorLinks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payorLinks',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  linkType: 'PARENT_OF',
  toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payorLinks',
  headers: {'content-type': 'application/json'},
  body: {
    fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    linkType: 'PARENT_OF',
    toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payorLinks');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  linkType: 'PARENT_OF',
  toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payorLinks',
  headers: {'content-type': 'application/json'},
  data: {
    fromPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    linkType: 'PARENT_OF',
    toPayorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payorLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fromPayorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91","linkType":"PARENT_OF","toPayorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fromPayorId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91",
                              @"linkType": @"PARENT_OF",
                              @"toPayorId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payorLinks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payorLinks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payorLinks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fromPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    'linkType' => 'PARENT_OF',
    'toPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payorLinks', [
  'body' => '{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payorLinks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fromPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  'linkType' => 'PARENT_OF',
  'toPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'fromPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  'linkType' => 'PARENT_OF',
  'toPayorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));
$request->setRequestUrl('{{baseUrl}}/v1/payorLinks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payorLinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payorLinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/payorLinks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payorLinks"

payload = {
    "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "linkType": "PARENT_OF",
    "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payorLinks"

payload <- "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payorLinks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/payorLinks') do |req|
  req.body = "{\n  \"fromPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"linkType\": \"PARENT_OF\",\n  \"toPayorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payorLinks";

    let payload = json!({
        "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "linkType": "PARENT_OF",
        "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payorLinks \
  --header 'content-type: application/json' \
  --data '{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
echo '{
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}' |  \
  http POST {{baseUrl}}/v1/payorLinks \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",\n  "linkType": "PARENT_OF",\n  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}' \
  --output-document \
  - {{baseUrl}}/v1/payorLinks
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fromPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "linkType": "PARENT_OF",
  "toPayorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payorLinks")! 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()
POST Create a quote for the payout
{{baseUrl}}/v3/payouts/:payoutId/quote
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId/quote");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payouts/:payoutId/quote")
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId/quote"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId/quote"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId/quote");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId/quote"

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

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

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

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

}
POST /baseUrl/v3/payouts/:payoutId/quote HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payouts/:payoutId/quote")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId/quote"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/quote")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payouts/:payoutId/quote")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payouts/:payoutId/quote');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v3/payouts/:payoutId/quote'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId/quote';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId/quote',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/quote")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId/quote',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v3/payouts/:payoutId/quote'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payouts/:payoutId/quote');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v3/payouts/:payoutId/quote'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId/quote';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId/quote"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId/quote" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId/quote",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payouts/:payoutId/quote');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId/quote');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId/quote');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId/quote' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId/quote' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v3/payouts/:payoutId/quote")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId/quote"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId/quote"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId/quote")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v3/payouts/:payoutId/quote') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId/quote";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payouts/:payoutId/quote
http POST {{baseUrl}}/v3/payouts/:payoutId/quote
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId/quote
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId/quote")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "fxSummaries": [
    {
      "creationTime": "2022-10-30T09:45:09Z",
      "expiryTime": "2022-10-30T09:50:09Z",
      "fundingStatus": "FUNDED",
      "invertedRate": 1.12,
      "paymentCurrency": "USD",
      "quoteId": "af80d455-29dd-4e72-a000-495a9829a7d0",
      "rate": 0.89,
      "sourceCurrency": "USD",
      "status": "QUOTED",
      "totalPaymentAmount": 890000,
      "totalSourceAmount": 1000000
    },
    {
      "creationTime": "2022-10-30T09:45:09Z",
      "expiryTime": "2022-10-30T09:50:09Z",
      "fundingStatus": "FUNDED",
      "invertedRate": 1.12,
      "paymentCurrency": "USD",
      "quoteId": "af80d455-29dd-4e72-a000-495a9829a7d0",
      "rate": 0.89,
      "sourceCurrency": "USD",
      "status": "QUOTED",
      "totalPaymentAmount": 890000,
      "totalSourceAmount": 1000000
    }
  ]
}
DELETE Deschedule a payout
{{baseUrl}}/v3/payouts/:payoutId/schedule
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId/schedule");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v3/payouts/:payoutId/schedule")
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId/schedule"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId/schedule"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId/schedule");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId/schedule"

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

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

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

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

}
DELETE /baseUrl/v3/payouts/:payoutId/schedule HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId/schedule"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v3/payouts/:payoutId/schedule');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId/schedule';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId/schedule',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/payouts/:payoutId/schedule');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId/schedule';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId/schedule"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId/schedule" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId/schedule",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v3/payouts/:payoutId/schedule');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId/schedule');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId/schedule');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId/schedule' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId/schedule' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v3/payouts/:payoutId/schedule")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId/schedule"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId/schedule"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId/schedule")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v3/payouts/:payoutId/schedule') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId/schedule";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v3/payouts/:payoutId/schedule
http DELETE {{baseUrl}}/v3/payouts/:payoutId/schedule
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId/schedule
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId/schedule")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
GET Get Payout Summary
{{baseUrl}}/v3/payouts/:payoutId
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payouts/:payoutId")
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId"

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

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

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

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

}
GET /baseUrl/v3/payouts/:payoutId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payouts/:payoutId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payouts/:payoutId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payouts/:payoutId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/payouts/:payoutId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/payouts/:payoutId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payouts/:payoutId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/payouts/:payoutId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payouts/:payoutId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payouts/:payoutId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payouts/:payoutId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/payouts/:payoutId
http GET {{baseUrl}}/v3/payouts/:payoutId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "acceptedPayments": [
    {
      "amount": 10000,
      "currencyType": "USD",
      "paymentMemo": "INV00112",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "railsId": "SVB",
      "remoteId": "remoteId1234",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account"
    },
    {
      "amount": 10000,
      "currencyType": "USD",
      "paymentMemo": "INV00112",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "railsId": "SVB",
      "remoteId": "remoteId1234",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account"
    }
  ],
  "accounts": [
    {
      "currency": "USD",
      "sourceAccountId": "cf81e490-4ab8-49c2-bd68-9d1e725480cb",
      "sourceAccountName": "AccountName",
      "totalPayoutCost": 1000000
    },
    {
      "currency": "USD",
      "sourceAccountId": "cf81e490-4ab8-49c2-bd68-9d1e725480cb",
      "sourceAccountName": "AccountName",
      "totalPayoutCost": 1000000
    }
  ],
  "fxSummaries": [
    {
      "creationTime": "2022-10-30T09:45:09Z",
      "expiryTime": "2022-10-30T09:50:09Z",
      "fundingStatus": "FUNDED",
      "invertedRate": 1.12,
      "paymentCurrency": "USD",
      "quoteId": "af80d455-29dd-4e72-a000-495a9829a7d0",
      "rate": 0.89,
      "sourceCurrency": "USD",
      "status": "QUOTED",
      "totalPaymentAmount": 890000,
      "totalSourceAmount": 1000000
    },
    {
      "creationTime": "2022-10-30T09:45:09Z",
      "expiryTime": "2022-10-30T09:50:09Z",
      "fundingStatus": "FUNDED",
      "invertedRate": 1.12,
      "paymentCurrency": "USD",
      "quoteId": "af80d455-29dd-4e72-a000-495a9829a7d0",
      "rate": 0.89,
      "sourceCurrency": "USD",
      "status": "QUOTED",
      "totalPaymentAmount": 890000,
      "totalSourceAmount": 1000000
    }
  ],
  "paymentsAccepted": 9,
  "paymentsRejected": 1,
  "paymentsSubmitted": 10,
  "paymentsWithdrawn": 0,
  "payoutId": "cf81e490-4ab8-49c2-bd68-9d1e725480cb",
  "rejectedPayments": [
    {
      "amount": 10000,
      "currencyType": "USD",
      "lineNumber": 34,
      "message": "Payment cannot be processed because of the Payee's OFAC or Compliance Status",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "reason": "The payee has not been onboarded",
      "reasonCode": "VE1012",
      "remoteId": "remoteIdVal123",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account"
    },
    {
      "amount": 10000,
      "currencyType": "USD",
      "lineNumber": 34,
      "message": "Payment cannot be processed because of the Payee's OFAC or Compliance Status",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "reason": "The payee has not been onboarded",
      "reasonCode": "VE1012",
      "remoteId": "remoteIdVal123",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account"
    }
  ],
  "schedule": {
    "notificationsEnabled": true,
    "scheduleStatus": "SCHEDULED",
    "scheduledAt": "2000-01-23T04:56:07.000+00:00",
    "scheduledByPrincipalId": "8946953b-1e3b-49cf-9da4-b704cbb78f3e",
    "scheduledFor": "2000-01-23T04:56:07.000+00:00"
  },
  "status": "COMPLETED"
}
POST Instruct Payout
{{baseUrl}}/v3/payouts/:payoutId
QUERY PARAMS

payoutId
BODY json

{
  "fxRateDegredationThresholdPercentage": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payouts/:payoutId" {:content-type :json
                                                                 :form-params {:fxRateDegredationThresholdPercentage 0.8008282}})
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId"),
    Content = new StringContent("{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId"

	payload := strings.NewReader("{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}")

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

	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))

}
POST /baseUrl/v3/payouts/:payoutId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "fxRateDegredationThresholdPercentage": 0.8008282
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payouts/:payoutId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payouts/:payoutId")
  .header("content-type", "application/json")
  .body("{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}")
  .asString();
const data = JSON.stringify({
  fxRateDegredationThresholdPercentage: 0.8008282
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payouts/:payoutId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  headers: {'content-type': 'application/json'},
  data: {fxRateDegredationThresholdPercentage: 0.8008282}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fxRateDegredationThresholdPercentage":0.8008282}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fxRateDegredationThresholdPercentage": 0.8008282\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({fxRateDegredationThresholdPercentage: 0.8008282}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  headers: {'content-type': 'application/json'},
  body: {fxRateDegredationThresholdPercentage: 0.8008282},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payouts/:payoutId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  fxRateDegredationThresholdPercentage: 0.8008282
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  headers: {'content-type': 'application/json'},
  data: {fxRateDegredationThresholdPercentage: 0.8008282}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fxRateDegredationThresholdPercentage":0.8008282}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fxRateDegredationThresholdPercentage": @0.8008282 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fxRateDegredationThresholdPercentage' => 0.8008282
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payouts/:payoutId', [
  'body' => '{
  "fxRateDegredationThresholdPercentage": 0.8008282
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fxRateDegredationThresholdPercentage' => 0.8008282
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'fxRateDegredationThresholdPercentage' => 0.8008282
]));
$request->setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fxRateDegredationThresholdPercentage": 0.8008282
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fxRateDegredationThresholdPercentage": 0.8008282
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payouts/:payoutId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId"

payload = { "fxRateDegredationThresholdPercentage": 0.8008282 }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId"

payload <- "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payouts/:payoutId') do |req|
  req.body = "{\n  \"fxRateDegredationThresholdPercentage\": 0.8008282\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId";

    let payload = json!({"fxRateDegredationThresholdPercentage": 0.8008282});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payouts/:payoutId \
  --header 'content-type: application/json' \
  --data '{
  "fxRateDegredationThresholdPercentage": 0.8008282
}'
echo '{
  "fxRateDegredationThresholdPercentage": 0.8008282
}' |  \
  http POST {{baseUrl}}/v3/payouts/:payoutId \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fxRateDegredationThresholdPercentage": 0.8008282\n}' \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["fxRateDegredationThresholdPercentage": 0.8008282] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId")! 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()
GET Retrieve payments for a payout
{{baseUrl}}/v3/payouts/:payoutId/payments
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId/payments");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/payouts/:payoutId/payments")
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId/payments"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId/payments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId/payments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId/payments"

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

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

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

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

}
GET /baseUrl/v3/payouts/:payoutId/payments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/payouts/:payoutId/payments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId/payments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/payments")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/payouts/:payoutId/payments")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/payouts/:payoutId/payments');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payouts/:payoutId/payments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId/payments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId/payments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/payments")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId/payments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payouts/:payoutId/payments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/payouts/:payoutId/payments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/payouts/:payoutId/payments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId/payments';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId/payments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId/payments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId/payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/payouts/:payoutId/payments');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId/payments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId/payments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId/payments' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId/payments' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/payouts/:payoutId/payments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId/payments"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId/payments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId/payments")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/payouts/:payoutId/payments') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId/payments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/payouts/:payoutId/payments
http GET {{baseUrl}}/v3/payouts/:payoutId/payments
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId/payments
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId/payments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "amount": 10000,
      "autoWithdrawnReasonCode": "VE0003",
      "currency": "USD",
      "payee": {
        "company": {
          "companyName": "ACME Anvils PLC"
        },
        "individual": {
          "name": {
            "firstName": "Fred",
            "lastName": "Flintstone"
          }
        },
        "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
      },
      "paymentId": "859af785-223b-4d5b-a708-5fa57f006dbb",
      "paymentMemo": "INV00112",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "railsId": "SVB",
      "remoteId": "remoteIdVal123",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account",
      "status": "AWAITING_FUNDS",
      "transmissionType": "LOCAL",
      "withdrawable": false
    },
    {
      "amount": 10000,
      "autoWithdrawnReasonCode": "VE0003",
      "currency": "USD",
      "payee": {
        "company": {
          "companyName": "ACME Anvils PLC"
        },
        "individual": {
          "name": {
            "firstName": "Fred",
            "lastName": "Flintstone"
          }
        },
        "payeeId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
      },
      "paymentId": "859af785-223b-4d5b-a708-5fa57f006dbb",
      "paymentMemo": "INV00112",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "railsId": "SVB",
      "remoteId": "remoteIdVal123",
      "remoteSystemId": "OB012",
      "sourceAccountName": "Chase Bank Account",
      "status": "AWAITING_FUNDS",
      "transmissionType": "LOCAL",
      "withdrawable": false
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
POST Schedule a payout
{{baseUrl}}/v3/payouts/:payoutId/schedule
QUERY PARAMS

payoutId
BODY json

{
  "notificationsEnabled": false,
  "scheduledFor": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId/schedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payouts/:payoutId/schedule" {:content-type :json
                                                                          :form-params {:notificationsEnabled true
                                                                                        :scheduledFor "2025-01-01T10:00:00Z"}})
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId/schedule"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId/schedule"),
    Content = new StringContent("{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId/schedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId/schedule"

	payload := strings.NewReader("{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}")

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

	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))

}
POST /baseUrl/v3/payouts/:payoutId/schedule HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId/schedule"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .header("content-type", "application/json")
  .body("{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}")
  .asString();
const data = JSON.stringify({
  notificationsEnabled: true,
  scheduledFor: '2025-01-01T10:00:00Z'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payouts/:payoutId/schedule');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule',
  headers: {'content-type': 'application/json'},
  data: {notificationsEnabled: true, scheduledFor: '2025-01-01T10:00:00Z'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId/schedule';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"notificationsEnabled":true,"scheduledFor":"2025-01-01T10:00:00Z"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "notificationsEnabled": true,\n  "scheduledFor": "2025-01-01T10:00:00Z"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId/schedule")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId/schedule',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({notificationsEnabled: true, scheduledFor: '2025-01-01T10:00:00Z'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule',
  headers: {'content-type': 'application/json'},
  body: {notificationsEnabled: true, scheduledFor: '2025-01-01T10:00:00Z'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payouts/:payoutId/schedule');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  notificationsEnabled: true,
  scheduledFor: '2025-01-01T10:00:00Z'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts/:payoutId/schedule',
  headers: {'content-type': 'application/json'},
  data: {notificationsEnabled: true, scheduledFor: '2025-01-01T10:00:00Z'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId/schedule';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"notificationsEnabled":true,"scheduledFor":"2025-01-01T10:00:00Z"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"notificationsEnabled": @YES,
                              @"scheduledFor": @"2025-01-01T10:00:00Z" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId/schedule"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId/schedule" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId/schedule",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'notificationsEnabled' => null,
    'scheduledFor' => '2025-01-01T10:00:00Z'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payouts/:payoutId/schedule', [
  'body' => '{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId/schedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'notificationsEnabled' => null,
  'scheduledFor' => '2025-01-01T10:00:00Z'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'notificationsEnabled' => null,
  'scheduledFor' => '2025-01-01T10:00:00Z'
]));
$request->setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId/schedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId/schedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId/schedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payouts/:payoutId/schedule", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId/schedule"

payload = {
    "notificationsEnabled": True,
    "scheduledFor": "2025-01-01T10:00:00Z"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId/schedule"

payload <- "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId/schedule")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payouts/:payoutId/schedule') do |req|
  req.body = "{\n  \"notificationsEnabled\": true,\n  \"scheduledFor\": \"2025-01-01T10:00:00Z\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId/schedule";

    let payload = json!({
        "notificationsEnabled": true,
        "scheduledFor": "2025-01-01T10:00:00Z"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payouts/:payoutId/schedule \
  --header 'content-type: application/json' \
  --data '{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}'
echo '{
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
}' |  \
  http POST {{baseUrl}}/v3/payouts/:payoutId/schedule \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "notificationsEnabled": true,\n  "scheduledFor": "2025-01-01T10:00:00Z"\n}' \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId/schedule
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "notificationsEnabled": true,
  "scheduledFor": "2025-01-01T10:00:00Z"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId/schedule")! 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()
POST Submit Payout
{{baseUrl}}/v3/payouts
BODY json

{
  "payments": [
    {
      "amount": 0,
      "currency": "",
      "paymentMemo": "",
      "paymentMetadata": "",
      "payorPaymentId": "",
      "remoteId": "",
      "remoteSystemId": "",
      "sourceAccountName": "",
      "transmissionType": ""
    }
  ],
  "payoutFromPayorId": "",
  "payoutMemo": "",
  "payoutToPayorId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/payouts" {:content-type :json
                                                       :form-params {:payments [{:amount 1299
                                                                                 :currency "USD"
                                                                                 :paymentMemo "my memo"
                                                                                 :paymentMetadata "invoiceeId_123|abc001:12345|xyz002:4567"
                                                                                 :payorPaymentId "123211321ABSD"
                                                                                 :remoteId "remoteId1234"
                                                                                 :remoteSystemId "remoteSystemId"
                                                                                 :sourceAccountName "MyAccountName"
                                                                                 :transmissionType "ACH"} {:amount 1299
                                                                                 :currency "USD"
                                                                                 :paymentMemo "my memo"
                                                                                 :paymentMetadata "invoiceeId_123|abc001:12345|xyz002:4567"
                                                                                 :payorPaymentId "123211321ABSD"
                                                                                 :remoteId "remoteId1234"
                                                                                 :remoteSystemId "remoteSystemId"
                                                                                 :sourceAccountName "MyAccountName"
                                                                                 :transmissionType "ACH"} {:amount 1299
                                                                                 :currency "USD"
                                                                                 :paymentMemo "my memo"
                                                                                 :paymentMetadata "invoiceeId_123|abc001:12345|xyz002:4567"
                                                                                 :payorPaymentId "123211321ABSD"
                                                                                 :remoteId "remoteId1234"
                                                                                 :remoteSystemId "remoteSystemId"
                                                                                 :sourceAccountName "MyAccountName"
                                                                                 :transmissionType "ACH"} {:amount 1299
                                                                                 :currency "USD"
                                                                                 :paymentMemo "my memo"
                                                                                 :paymentMetadata "invoiceeId_123|abc001:12345|xyz002:4567"
                                                                                 :payorPaymentId "123211321ABSD"
                                                                                 :remoteId "remoteId1234"
                                                                                 :remoteSystemId "remoteSystemId"
                                                                                 :sourceAccountName "MyAccountName"
                                                                                 :transmissionType "ACH"} {:amount 1299
                                                                                 :currency "USD"
                                                                                 :paymentMemo "my memo"
                                                                                 :paymentMetadata "invoiceeId_123|abc001:12345|xyz002:4567"
                                                                                 :payorPaymentId "123211321ABSD"
                                                                                 :remoteId "remoteId1234"
                                                                                 :remoteSystemId "remoteSystemId"
                                                                                 :sourceAccountName "MyAccountName"
                                                                                 :transmissionType "ACH"}]
                                                                     :payoutFromPayorId "c4261044-13df-4a6c-b1d4-fa8be2b46f5a"
                                                                     :payoutMemo "Monthly Payment"
                                                                     :payoutToPayorId "9afc6b39-de12-466a-a9ca-07c7a23b312d"}})
require "http/client"

url = "{{baseUrl}}/v3/payouts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts"),
    Content = new StringContent("{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts"

	payload := strings.NewReader("{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}")

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

	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))

}
POST /baseUrl/v3/payouts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1946

{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/payouts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/payouts")
  .header("content-type", "application/json")
  .body("{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}")
  .asString();
const data = JSON.stringify({
  payments: [
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    }
  ],
  payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
  payoutMemo: 'Monthly Payment',
  payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/payouts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts',
  headers: {'content-type': 'application/json'},
  data: {
    payments: [
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      }
    ],
    payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
    payoutMemo: 'Monthly Payment',
    payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payments":[{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"}],"payoutFromPayorId":"c4261044-13df-4a6c-b1d4-fa8be2b46f5a","payoutMemo":"Monthly Payment","payoutToPayorId":"9afc6b39-de12-466a-a9ca-07c7a23b312d"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payments": [\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    }\n  ],\n  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",\n  "payoutMemo": "Monthly Payment",\n  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  payments: [
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    }
  ],
  payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
  payoutMemo: 'Monthly Payment',
  payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts',
  headers: {'content-type': 'application/json'},
  body: {
    payments: [
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      }
    ],
    payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
    payoutMemo: 'Monthly Payment',
    payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/payouts');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payments: [
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    },
    {
      amount: 1299,
      currency: 'USD',
      paymentMemo: 'my memo',
      paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
      payorPaymentId: '123211321ABSD',
      remoteId: 'remoteId1234',
      remoteSystemId: 'remoteSystemId',
      sourceAccountName: 'MyAccountName',
      transmissionType: 'ACH'
    }
  ],
  payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
  payoutMemo: 'Monthly Payment',
  payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/payouts',
  headers: {'content-type': 'application/json'},
  data: {
    payments: [
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      },
      {
        amount: 1299,
        currency: 'USD',
        paymentMemo: 'my memo',
        paymentMetadata: 'invoiceeId_123|abc001:12345|xyz002:4567',
        payorPaymentId: '123211321ABSD',
        remoteId: 'remoteId1234',
        remoteSystemId: 'remoteSystemId',
        sourceAccountName: 'MyAccountName',
        transmissionType: 'ACH'
      }
    ],
    payoutFromPayorId: 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
    payoutMemo: 'Monthly Payment',
    payoutToPayorId: '9afc6b39-de12-466a-a9ca-07c7a23b312d'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payments":[{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"},{"amount":1299,"currency":"USD","paymentMemo":"my memo","paymentMetadata":"invoiceeId_123|abc001:12345|xyz002:4567","payorPaymentId":"123211321ABSD","remoteId":"remoteId1234","remoteSystemId":"remoteSystemId","sourceAccountName":"MyAccountName","transmissionType":"ACH"}],"payoutFromPayorId":"c4261044-13df-4a6c-b1d4-fa8be2b46f5a","payoutMemo":"Monthly Payment","payoutToPayorId":"9afc6b39-de12-466a-a9ca-07c7a23b312d"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payments": @[ @{ @"amount": @1299, @"currency": @"USD", @"paymentMemo": @"my memo", @"paymentMetadata": @"invoiceeId_123|abc001:12345|xyz002:4567", @"payorPaymentId": @"123211321ABSD", @"remoteId": @"remoteId1234", @"remoteSystemId": @"remoteSystemId", @"sourceAccountName": @"MyAccountName", @"transmissionType": @"ACH" }, @{ @"amount": @1299, @"currency": @"USD", @"paymentMemo": @"my memo", @"paymentMetadata": @"invoiceeId_123|abc001:12345|xyz002:4567", @"payorPaymentId": @"123211321ABSD", @"remoteId": @"remoteId1234", @"remoteSystemId": @"remoteSystemId", @"sourceAccountName": @"MyAccountName", @"transmissionType": @"ACH" }, @{ @"amount": @1299, @"currency": @"USD", @"paymentMemo": @"my memo", @"paymentMetadata": @"invoiceeId_123|abc001:12345|xyz002:4567", @"payorPaymentId": @"123211321ABSD", @"remoteId": @"remoteId1234", @"remoteSystemId": @"remoteSystemId", @"sourceAccountName": @"MyAccountName", @"transmissionType": @"ACH" }, @{ @"amount": @1299, @"currency": @"USD", @"paymentMemo": @"my memo", @"paymentMetadata": @"invoiceeId_123|abc001:12345|xyz002:4567", @"payorPaymentId": @"123211321ABSD", @"remoteId": @"remoteId1234", @"remoteSystemId": @"remoteSystemId", @"sourceAccountName": @"MyAccountName", @"transmissionType": @"ACH" }, @{ @"amount": @1299, @"currency": @"USD", @"paymentMemo": @"my memo", @"paymentMetadata": @"invoiceeId_123|abc001:12345|xyz002:4567", @"payorPaymentId": @"123211321ABSD", @"remoteId": @"remoteId1234", @"remoteSystemId": @"remoteSystemId", @"sourceAccountName": @"MyAccountName", @"transmissionType": @"ACH" } ],
                              @"payoutFromPayorId": @"c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
                              @"payoutMemo": @"Monthly Payment",
                              @"payoutToPayorId": @"9afc6b39-de12-466a-a9ca-07c7a23b312d" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'payments' => [
        [
                'amount' => 1299,
                'currency' => 'USD',
                'paymentMemo' => 'my memo',
                'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
                'payorPaymentId' => '123211321ABSD',
                'remoteId' => 'remoteId1234',
                'remoteSystemId' => 'remoteSystemId',
                'sourceAccountName' => 'MyAccountName',
                'transmissionType' => 'ACH'
        ],
        [
                'amount' => 1299,
                'currency' => 'USD',
                'paymentMemo' => 'my memo',
                'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
                'payorPaymentId' => '123211321ABSD',
                'remoteId' => 'remoteId1234',
                'remoteSystemId' => 'remoteSystemId',
                'sourceAccountName' => 'MyAccountName',
                'transmissionType' => 'ACH'
        ],
        [
                'amount' => 1299,
                'currency' => 'USD',
                'paymentMemo' => 'my memo',
                'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
                'payorPaymentId' => '123211321ABSD',
                'remoteId' => 'remoteId1234',
                'remoteSystemId' => 'remoteSystemId',
                'sourceAccountName' => 'MyAccountName',
                'transmissionType' => 'ACH'
        ],
        [
                'amount' => 1299,
                'currency' => 'USD',
                'paymentMemo' => 'my memo',
                'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
                'payorPaymentId' => '123211321ABSD',
                'remoteId' => 'remoteId1234',
                'remoteSystemId' => 'remoteSystemId',
                'sourceAccountName' => 'MyAccountName',
                'transmissionType' => 'ACH'
        ],
        [
                'amount' => 1299,
                'currency' => 'USD',
                'paymentMemo' => 'my memo',
                'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
                'payorPaymentId' => '123211321ABSD',
                'remoteId' => 'remoteId1234',
                'remoteSystemId' => 'remoteSystemId',
                'sourceAccountName' => 'MyAccountName',
                'transmissionType' => 'ACH'
        ]
    ],
    'payoutFromPayorId' => 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
    'payoutMemo' => 'Monthly Payment',
    'payoutToPayorId' => '9afc6b39-de12-466a-a9ca-07c7a23b312d'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/payouts', [
  'body' => '{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payments' => [
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ]
  ],
  'payoutFromPayorId' => 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
  'payoutMemo' => 'Monthly Payment',
  'payoutToPayorId' => '9afc6b39-de12-466a-a9ca-07c7a23b312d'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'payments' => [
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ],
    [
        'amount' => 1299,
        'currency' => 'USD',
        'paymentMemo' => 'my memo',
        'paymentMetadata' => 'invoiceeId_123|abc001:12345|xyz002:4567',
        'payorPaymentId' => '123211321ABSD',
        'remoteId' => 'remoteId1234',
        'remoteSystemId' => 'remoteSystemId',
        'sourceAccountName' => 'MyAccountName',
        'transmissionType' => 'ACH'
    ]
  ],
  'payoutFromPayorId' => 'c4261044-13df-4a6c-b1d4-fa8be2b46f5a',
  'payoutMemo' => 'Monthly Payment',
  'payoutToPayorId' => '9afc6b39-de12-466a-a9ca-07c7a23b312d'
]));
$request->setRequestUrl('{{baseUrl}}/v3/payouts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/payouts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts"

payload = {
    "payments": [
        {
            "amount": 1299,
            "currency": "USD",
            "paymentMemo": "my memo",
            "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
            "payorPaymentId": "123211321ABSD",
            "remoteId": "remoteId1234",
            "remoteSystemId": "remoteSystemId",
            "sourceAccountName": "MyAccountName",
            "transmissionType": "ACH"
        },
        {
            "amount": 1299,
            "currency": "USD",
            "paymentMemo": "my memo",
            "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
            "payorPaymentId": "123211321ABSD",
            "remoteId": "remoteId1234",
            "remoteSystemId": "remoteSystemId",
            "sourceAccountName": "MyAccountName",
            "transmissionType": "ACH"
        },
        {
            "amount": 1299,
            "currency": "USD",
            "paymentMemo": "my memo",
            "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
            "payorPaymentId": "123211321ABSD",
            "remoteId": "remoteId1234",
            "remoteSystemId": "remoteSystemId",
            "sourceAccountName": "MyAccountName",
            "transmissionType": "ACH"
        },
        {
            "amount": 1299,
            "currency": "USD",
            "paymentMemo": "my memo",
            "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
            "payorPaymentId": "123211321ABSD",
            "remoteId": "remoteId1234",
            "remoteSystemId": "remoteSystemId",
            "sourceAccountName": "MyAccountName",
            "transmissionType": "ACH"
        },
        {
            "amount": 1299,
            "currency": "USD",
            "paymentMemo": "my memo",
            "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
            "payorPaymentId": "123211321ABSD",
            "remoteId": "remoteId1234",
            "remoteSystemId": "remoteSystemId",
            "sourceAccountName": "MyAccountName",
            "transmissionType": "ACH"
        }
    ],
    "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
    "payoutMemo": "Monthly Payment",
    "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts"

payload <- "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/payouts') do |req|
  req.body = "{\n  \"payments\": [\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    },\n    {\n      \"amount\": 1299,\n      \"currency\": \"USD\",\n      \"paymentMemo\": \"my memo\",\n      \"paymentMetadata\": \"invoiceeId_123|abc001:12345|xyz002:4567\",\n      \"payorPaymentId\": \"123211321ABSD\",\n      \"remoteId\": \"remoteId1234\",\n      \"remoteSystemId\": \"remoteSystemId\",\n      \"sourceAccountName\": \"MyAccountName\",\n      \"transmissionType\": \"ACH\"\n    }\n  ],\n  \"payoutFromPayorId\": \"c4261044-13df-4a6c-b1d4-fa8be2b46f5a\",\n  \"payoutMemo\": \"Monthly Payment\",\n  \"payoutToPayorId\": \"9afc6b39-de12-466a-a9ca-07c7a23b312d\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts";

    let payload = json!({
        "payments": (
            json!({
                "amount": 1299,
                "currency": "USD",
                "paymentMemo": "my memo",
                "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
                "payorPaymentId": "123211321ABSD",
                "remoteId": "remoteId1234",
                "remoteSystemId": "remoteSystemId",
                "sourceAccountName": "MyAccountName",
                "transmissionType": "ACH"
            }),
            json!({
                "amount": 1299,
                "currency": "USD",
                "paymentMemo": "my memo",
                "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
                "payorPaymentId": "123211321ABSD",
                "remoteId": "remoteId1234",
                "remoteSystemId": "remoteSystemId",
                "sourceAccountName": "MyAccountName",
                "transmissionType": "ACH"
            }),
            json!({
                "amount": 1299,
                "currency": "USD",
                "paymentMemo": "my memo",
                "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
                "payorPaymentId": "123211321ABSD",
                "remoteId": "remoteId1234",
                "remoteSystemId": "remoteSystemId",
                "sourceAccountName": "MyAccountName",
                "transmissionType": "ACH"
            }),
            json!({
                "amount": 1299,
                "currency": "USD",
                "paymentMemo": "my memo",
                "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
                "payorPaymentId": "123211321ABSD",
                "remoteId": "remoteId1234",
                "remoteSystemId": "remoteSystemId",
                "sourceAccountName": "MyAccountName",
                "transmissionType": "ACH"
            }),
            json!({
                "amount": 1299,
                "currency": "USD",
                "paymentMemo": "my memo",
                "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
                "payorPaymentId": "123211321ABSD",
                "remoteId": "remoteId1234",
                "remoteSystemId": "remoteSystemId",
                "sourceAccountName": "MyAccountName",
                "transmissionType": "ACH"
            })
        ),
        "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
        "payoutMemo": "Monthly Payment",
        "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/payouts \
  --header 'content-type: application/json' \
  --data '{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}'
echo '{
  "payments": [
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    },
    {
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    }
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
}' |  \
  http POST {{baseUrl}}/v3/payouts \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payments": [\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    },\n    {\n      "amount": 1299,\n      "currency": "USD",\n      "paymentMemo": "my memo",\n      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",\n      "payorPaymentId": "123211321ABSD",\n      "remoteId": "remoteId1234",\n      "remoteSystemId": "remoteSystemId",\n      "sourceAccountName": "MyAccountName",\n      "transmissionType": "ACH"\n    }\n  ],\n  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",\n  "payoutMemo": "Monthly Payment",\n  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"\n}' \
  --output-document \
  - {{baseUrl}}/v3/payouts
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payments": [
    [
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    ],
    [
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    ],
    [
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    ],
    [
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    ],
    [
      "amount": 1299,
      "currency": "USD",
      "paymentMemo": "my memo",
      "paymentMetadata": "invoiceeId_123|abc001:12345|xyz002:4567",
      "payorPaymentId": "123211321ABSD",
      "remoteId": "remoteId1234",
      "remoteSystemId": "remoteSystemId",
      "sourceAccountName": "MyAccountName",
      "transmissionType": "ACH"
    ]
  ],
  "payoutFromPayorId": "c4261044-13df-4a6c-b1d4-fa8be2b46f5a",
  "payoutMemo": "Monthly Payment",
  "payoutToPayorId": "9afc6b39-de12-466a-a9ca-07c7a23b312d"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/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()
DELETE Withdraw Payout
{{baseUrl}}/v3/payouts/:payoutId
QUERY PARAMS

payoutId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/payouts/:payoutId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v3/payouts/:payoutId")
require "http/client"

url = "{{baseUrl}}/v3/payouts/:payoutId"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v3/payouts/:payoutId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/payouts/:payoutId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/payouts/:payoutId"

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

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

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

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

}
DELETE /baseUrl/v3/payouts/:payoutId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/payouts/:payoutId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/payouts/:payoutId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v3/payouts/:payoutId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v3/payouts/:payoutId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payouts/:payoutId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/payouts/:payoutId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/payouts/:payoutId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/payouts/:payoutId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payouts/:payoutId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/payouts/:payoutId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v3/payouts/:payoutId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/payouts/:payoutId';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/payouts/:payoutId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/payouts/:payoutId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/payouts/:payoutId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v3/payouts/:payoutId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/payouts/:payoutId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/payouts/:payoutId' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v3/payouts/:payoutId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/payouts/:payoutId"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/payouts/:payoutId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/payouts/:payoutId")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v3/payouts/:payoutId') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/payouts/:payoutId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v3/payouts/:payoutId
http DELETE {{baseUrl}}/v3/payouts/:payoutId
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/payouts/:payoutId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/payouts/:payoutId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
POST Withdraw a Payment
{{baseUrl}}/v1/payments/:paymentId/withdraw
QUERY PARAMS

paymentId
BODY json

{
  "reason": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/payments/:paymentId/withdraw");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"reason\": \"Payment submitted in error\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/payments/:paymentId/withdraw" {:content-type :json
                                                                            :form-params {:reason "Payment submitted in error"}})
require "http/client"

url = "{{baseUrl}}/v1/payments/:paymentId/withdraw"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reason\": \"Payment submitted in error\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/payments/:paymentId/withdraw"),
    Content = new StringContent("{\n  \"reason\": \"Payment submitted in error\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/payments/:paymentId/withdraw");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reason\": \"Payment submitted in error\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/payments/:paymentId/withdraw"

	payload := strings.NewReader("{\n  \"reason\": \"Payment submitted in error\"\n}")

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

	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))

}
POST /baseUrl/v1/payments/:paymentId/withdraw HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "reason": "Payment submitted in error"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/payments/:paymentId/withdraw")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reason\": \"Payment submitted in error\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/payments/:paymentId/withdraw"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"reason\": \"Payment submitted in error\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"reason\": \"Payment submitted in error\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/payments/:paymentId/withdraw")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/payments/:paymentId/withdraw")
  .header("content-type", "application/json")
  .body("{\n  \"reason\": \"Payment submitted in error\"\n}")
  .asString();
const data = JSON.stringify({
  reason: 'Payment submitted in error'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/payments/:paymentId/withdraw');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payments/:paymentId/withdraw',
  headers: {'content-type': 'application/json'},
  data: {reason: 'Payment submitted in error'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/payments/:paymentId/withdraw';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reason":"Payment submitted in error"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/payments/:paymentId/withdraw',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reason": "Payment submitted in error"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reason\": \"Payment submitted in error\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/payments/:paymentId/withdraw")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/payments/:paymentId/withdraw',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({reason: 'Payment submitted in error'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payments/:paymentId/withdraw',
  headers: {'content-type': 'application/json'},
  body: {reason: 'Payment submitted in error'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/payments/:paymentId/withdraw');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  reason: 'Payment submitted in error'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/payments/:paymentId/withdraw',
  headers: {'content-type': 'application/json'},
  data: {reason: 'Payment submitted in error'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/payments/:paymentId/withdraw';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reason":"Payment submitted in error"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reason": @"Payment submitted in error" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/payments/:paymentId/withdraw"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/payments/:paymentId/withdraw" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reason\": \"Payment submitted in error\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/payments/:paymentId/withdraw",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'reason' => 'Payment submitted in error'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/payments/:paymentId/withdraw', [
  'body' => '{
  "reason": "Payment submitted in error"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/payments/:paymentId/withdraw');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reason' => 'Payment submitted in error'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'reason' => 'Payment submitted in error'
]));
$request->setRequestUrl('{{baseUrl}}/v1/payments/:paymentId/withdraw');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/payments/:paymentId/withdraw' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reason": "Payment submitted in error"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/payments/:paymentId/withdraw' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reason": "Payment submitted in error"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reason\": \"Payment submitted in error\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/payments/:paymentId/withdraw", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/payments/:paymentId/withdraw"

payload = { "reason": "Payment submitted in error" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/payments/:paymentId/withdraw"

payload <- "{\n  \"reason\": \"Payment submitted in error\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/payments/:paymentId/withdraw")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reason\": \"Payment submitted in error\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/payments/:paymentId/withdraw') do |req|
  req.body = "{\n  \"reason\": \"Payment submitted in error\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/payments/:paymentId/withdraw";

    let payload = json!({"reason": "Payment submitted in error"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/payments/:paymentId/withdraw \
  --header 'content-type: application/json' \
  --data '{
  "reason": "Payment submitted in error"
}'
echo '{
  "reason": "Payment submitted in error"
}' |  \
  http POST {{baseUrl}}/v1/payments/:paymentId/withdraw \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "reason": "Payment submitted in error"\n}' \
  --output-document \
  - {{baseUrl}}/v1/payments/:paymentId/withdraw
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["reason": "Payment submitted in error"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/payments/:paymentId/withdraw")! 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()
GET Get Source Account
{{baseUrl}}/v2/sourceAccounts/:sourceAccountId
QUERY PARAMS

sourceAccountId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")
require "http/client"

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"

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

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

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

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

}
GET /baseUrl/v2/sourceAccounts/:sourceAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/sourceAccounts/:sourceAccountId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/sourceAccounts/:sourceAccountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/sourceAccounts/:sourceAccountId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/sourceAccounts/:sourceAccountId
http GET {{baseUrl}}/v2/sourceAccounts/:sourceAccountId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/sourceAccounts/:sourceAccountId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "accountType": "FBO",
  "autoTopUpConfig": {
    "enabled": true,
    "minBalance": 10000,
    "targetBalance": 300000
  },
  "balance": 1203489,
  "balanceVisible": true,
  "currency": "USD",
  "customerId": "Joe Customer",
  "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "fundingRef": "a1b2c3d4",
  "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "name": "MyAccountName",
  "notifications": {
    "minimumBalance": 120000
  },
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "physicalAccountName": "VELO_FBO_MYBANKA_USD",
  "pooled": true,
  "railsId": "BOA_RAIL"
}
GET Get details about given source account.
{{baseUrl}}/v3/sourceAccounts/:sourceAccountId
QUERY PARAMS

sourceAccountId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

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

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

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

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

}
GET /baseUrl/v3/sourceAccounts/:sourceAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts/:sourceAccountId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/sourceAccounts/:sourceAccountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/sourceAccounts/:sourceAccountId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
http GET {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts/:sourceAccountId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "autoTopUpConfig": {
    "enabled": true,
    "fundingAccountId": "640ab1bd-8a6a-4603-a83a-1edbc3ed5689",
    "minBalance": 10000,
    "targetBalance": 300000
  },
  "balance": 1203489,
  "country": "US",
  "currency": "USD",
  "customerId": "Joe Customer",
  "deleted": true,
  "deletedAt": "2021-01-27T10:08:25.701Z",
  "fundingRef": "a1b2c3d4",
  "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "name": "MyAccountName",
  "notifications": {
    "minimumBalance": 120000
  },
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "physicalAccountName": "VELO_FBO_MYBANKA_USD",
  "pooled": true,
  "railsId": "BOA_RAIL",
  "type": "FBO",
  "userDeleted": true
}
GET Get list of source accounts (GET)
{{baseUrl}}/v3/sourceAccounts
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/sourceAccounts")
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts"

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

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

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

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

}
GET /baseUrl/v3/sourceAccounts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/sourceAccounts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v3/sourceAccounts")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/sourceAccounts');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/sourceAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/sourceAccounts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/sourceAccounts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/sourceAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v3/sourceAccounts');

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v3/sourceAccounts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/sourceAccounts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/sourceAccounts') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v3/sourceAccounts
http GET {{baseUrl}}/v3/sourceAccounts
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "autoTopUpConfig": {
        "enabled": true,
        "fundingAccountId": "640ab1bd-8a6a-4603-a83a-1edbc3ed5689",
        "minBalance": 10000,
        "targetBalance": 300000
      },
      "balance": 1203489,
      "country": "US",
      "currency": "USD",
      "customerId": "Joe Customer",
      "deleted": true,
      "deletedAt": "2021-01-27T10:08:25.701Z",
      "fundingRef": "a1b2c3d4",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "MyAccountName",
      "notifications": {
        "minimumBalance": 120000
      },
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountName": "VELO_FBO_MYBANKA_USD",
      "pooled": true,
      "railsId": "BOA_RAIL",
      "type": "FBO",
      "userDeleted": true
    },
    {
      "autoTopUpConfig": {
        "enabled": true,
        "fundingAccountId": "640ab1bd-8a6a-4603-a83a-1edbc3ed5689",
        "minBalance": 10000,
        "targetBalance": 300000
      },
      "balance": 1203489,
      "country": "US",
      "currency": "USD",
      "customerId": "Joe Customer",
      "deleted": true,
      "deletedAt": "2021-01-27T10:08:25.701Z",
      "fundingRef": "a1b2c3d4",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "MyAccountName",
      "notifications": {
        "minimumBalance": 120000
      },
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountName": "VELO_FBO_MYBANKA_USD",
      "pooled": true,
      "railsId": "BOA_RAIL",
      "type": "FBO",
      "userDeleted": true
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v3/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v3/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 33,
    "totalPages": 2
  }
}
GET Get list of source accounts
{{baseUrl}}/v2/sourceAccounts
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/sourceAccounts");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/sourceAccounts")
require "http/client"

url = "{{baseUrl}}/v2/sourceAccounts"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/sourceAccounts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/sourceAccounts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/sourceAccounts"

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

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

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

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

}
GET /baseUrl/v2/sourceAccounts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/sourceAccounts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/sourceAccounts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/sourceAccounts")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/sourceAccounts');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/sourceAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/sourceAccounts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/sourceAccounts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/sourceAccounts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/sourceAccounts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/sourceAccounts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/sourceAccounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/sourceAccounts';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/sourceAccounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/sourceAccounts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/sourceAccounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/sourceAccounts');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/sourceAccounts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/sourceAccounts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/sourceAccounts' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/sourceAccounts' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/sourceAccounts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/sourceAccounts"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/sourceAccounts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/sourceAccounts")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/sourceAccounts') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/sourceAccounts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/sourceAccounts
http GET {{baseUrl}}/v2/sourceAccounts
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/sourceAccounts
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/sourceAccounts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "accountType": "FBO",
      "autoTopUpConfig": {
        "enabled": true,
        "minBalance": 10000,
        "targetBalance": 300000
      },
      "balance": 1203489,
      "balanceVisible": true,
      "currency": "USD",
      "customerId": "Joe Customer",
      "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "fundingRef": "a1b2c3d4",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "MyAccountName",
      "notifications": {
        "minimumBalance": 120000
      },
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountName": "VELO_FBO_MYBANKA_USD",
      "pooled": true,
      "railsId": "BOA_RAIL"
    },
    {
      "accountType": "FBO",
      "autoTopUpConfig": {
        "enabled": true,
        "minBalance": 10000,
        "targetBalance": 300000
      },
      "balance": 1203489,
      "balanceVisible": true,
      "currency": "USD",
      "customerId": "Joe Customer",
      "fundingAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "fundingRef": "a1b2c3d4",
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "name": "MyAccountName",
      "notifications": {
        "minimumBalance": 120000
      },
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "physicalAccountName": "VELO_FBO_MYBANKA_USD",
      "pooled": true,
      "railsId": "BOA_RAIL"
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v2/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v2/sourceAccounts?payorId=a2967711-df07-41e5-b5ea-f563088911c6&page=1&pageSize=0&sort=fundingRef:asc",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 33,
    "totalPages": 2
  }
}
POST Set notifications (POST)
{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications
QUERY PARAMS

sourceAccountId
BODY json

{
  "minimumBalance": 0
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"minimumBalance\": 10000000\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications" {:content-type :json
                                                                                             :form-params {:minimumBalance 10000000}})
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"minimumBalance\": 10000000\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"),
    Content = new StringContent("{\n  \"minimumBalance\": 10000000\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"minimumBalance\": 10000000\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"

	payload := strings.NewReader("{\n  \"minimumBalance\": 10000000\n}")

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

	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))

}
POST /baseUrl/v3/sourceAccounts/:sourceAccountId/notifications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "minimumBalance": 10000000
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"minimumBalance\": 10000000\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"minimumBalance\": 10000000\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"minimumBalance\": 10000000\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")
  .header("content-type", "application/json")
  .body("{\n  \"minimumBalance\": 10000000\n}")
  .asString();
const data = JSON.stringify({
  minimumBalance: 10000000
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  data: {minimumBalance: 10000000}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"minimumBalance":10000000}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "minimumBalance": 10000000\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"minimumBalance\": 10000000\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts/:sourceAccountId/notifications',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({minimumBalance: 10000000}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  body: {minimumBalance: 10000000},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  minimumBalance: 10000000
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  data: {minimumBalance: 10000000}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"minimumBalance":10000000}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"minimumBalance": @10000000 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"minimumBalance\": 10000000\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'minimumBalance' => 10000000
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications', [
  'body' => '{
  "minimumBalance": 10000000
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'minimumBalance' => 10000000
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'minimumBalance' => 10000000
]));
$request->setRequestUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "minimumBalance": 10000000
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "minimumBalance": 10000000
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"minimumBalance\": 10000000\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/sourceAccounts/:sourceAccountId/notifications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"

payload = { "minimumBalance": 10000000 }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications"

payload <- "{\n  \"minimumBalance\": 10000000\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"minimumBalance\": 10000000\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/sourceAccounts/:sourceAccountId/notifications') do |req|
  req.body = "{\n  \"minimumBalance\": 10000000\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications";

    let payload = json!({"minimumBalance": 10000000});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications \
  --header 'content-type: application/json' \
  --data '{
  "minimumBalance": 10000000
}'
echo '{
  "minimumBalance": 10000000
}' |  \
  http POST {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "minimumBalance": 10000000\n}' \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["minimumBalance": 10000000] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/notifications")! 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()
POST Set notifications
{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications
QUERY PARAMS

sourceAccountId
BODY json

{
  "minimumBalance": 0
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"minimumBalance\": 800828190\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications" {:content-type :json
                                                                                             :form-params {:minimumBalance 800828190}})
require "http/client"

url = "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"minimumBalance\": 800828190\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"),
    Content = new StringContent("{\n  \"minimumBalance\": 800828190\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"minimumBalance\": 800828190\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"

	payload := strings.NewReader("{\n  \"minimumBalance\": 800828190\n}")

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

	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))

}
POST /baseUrl/v1/sourceAccounts/:sourceAccountId/notifications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "minimumBalance": 800828190
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"minimumBalance\": 800828190\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"minimumBalance\": 800828190\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"minimumBalance\": 800828190\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")
  .header("content-type", "application/json")
  .body("{\n  \"minimumBalance\": 800828190\n}")
  .asString();
const data = JSON.stringify({
  minimumBalance: 800828190
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  data: {minimumBalance: 800828190}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"minimumBalance":800828190}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "minimumBalance": 800828190\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"minimumBalance\": 800828190\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/sourceAccounts/:sourceAccountId/notifications',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({minimumBalance: 800828190}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  body: {minimumBalance: 800828190},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  minimumBalance: 800828190
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications',
  headers: {'content-type': 'application/json'},
  data: {minimumBalance: 800828190}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"minimumBalance":800828190}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"minimumBalance": @800828190 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"minimumBalance\": 800828190\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'minimumBalance' => 800828190
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications', [
  'body' => '{
  "minimumBalance": 800828190
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'minimumBalance' => 800828190
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'minimumBalance' => 800828190
]));
$request->setRequestUrl('{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "minimumBalance": 800828190
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "minimumBalance": 800828190
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"minimumBalance\": 800828190\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/sourceAccounts/:sourceAccountId/notifications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"

payload = { "minimumBalance": 800828190 }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications"

payload <- "{\n  \"minimumBalance\": 800828190\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"minimumBalance\": 800828190\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/sourceAccounts/:sourceAccountId/notifications') do |req|
  req.body = "{\n  \"minimumBalance\": 800828190\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications";

    let payload = json!({"minimumBalance": 800828190});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications \
  --header 'content-type: application/json' \
  --data '{
  "minimumBalance": 800828190
}'
echo '{
  "minimumBalance": 800828190
}' |  \
  http POST {{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "minimumBalance": 800828190\n}' \
  --output-document \
  - {{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["minimumBalance": 800828190] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/sourceAccounts/:sourceAccountId/notifications")! 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()
POST Transfer Funds between source accounts (POST)
{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers
QUERY PARAMS

sourceAccountId
BODY json

{
  "amount": 0,
  "currency": "",
  "toSourceAccountId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers" {:content-type :json
                                                                                         :form-params {:amount 800828191
                                                                                                       :currency "USD"
                                                                                                       :toSourceAccountId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"}})
require "http/client"

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"),
    Content = new StringContent("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"

	payload := strings.NewReader("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")

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

	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))

}
POST /baseUrl/v3/sourceAccounts/:sourceAccountId/transfers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .asString();
const data = JSON.stringify({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  data: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"currency":"USD","toSourceAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 800828191,\n  "currency": "USD",\n  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/sourceAccounts/:sourceAccountId/transfers',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  body: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  data: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"currency":"USD","toSourceAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @800828191,
                              @"currency": @"USD",
                              @"toSourceAccountId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => 800828191,
    'currency' => 'USD',
    'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers', [
  'body' => '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 800828191,
  'currency' => 'USD',
  'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'amount' => 800828191,
  'currency' => 'USD',
  'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));
$request->setRequestUrl('{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v3/sourceAccounts/:sourceAccountId/transfers", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"

payload = {
    "amount": 800828191,
    "currency": "USD",
    "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers"

payload <- "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v3/sourceAccounts/:sourceAccountId/transfers') do |req|
  req.body = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers";

    let payload = json!({
        "amount": 800828191,
        "currency": "USD",
        "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers \
  --header 'content-type: application/json' \
  --data '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
echo '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}' |  \
  http POST {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 800828191,\n  "currency": "USD",\n  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}' \
  --output-document \
  - {{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/sourceAccounts/:sourceAccountId/transfers")! 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()
POST Transfer Funds between source accounts
{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers
QUERY PARAMS

sourceAccountId
BODY json

{
  "amount": 0,
  "currency": "",
  "toSourceAccountId": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers" {:content-type :json
                                                                                         :form-params {:amount 800828191
                                                                                                       :currency "USD"
                                                                                                       :toSourceAccountId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"}})
require "http/client"

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"),
    Content = new StringContent("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"

	payload := strings.NewReader("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")

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

	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))

}
POST /baseUrl/v2/sourceAccounts/:sourceAccountId/transfers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
  .asString();
const data = JSON.stringify({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  data: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"currency":"USD","toSourceAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": 800828191,\n  "currency": "USD",\n  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/sourceAccounts/:sourceAccountId/transfers',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  body: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: 800828191,
  currency: 'USD',
  toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers',
  headers: {'content-type': 'application/json'},
  data: {
    amount: 800828191,
    currency: 'USD',
    toSourceAccountId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":800828191,"currency":"USD","toSourceAccountId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @800828191,
                              @"currency": @"USD",
                              @"toSourceAccountId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => 800828191,
    'currency' => 'USD',
    'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers', [
  'body' => '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => 800828191,
  'currency' => 'USD',
  'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'amount' => 800828191,
  'currency' => 'USD',
  'toSourceAccountId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91'
]));
$request->setRequestUrl('{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/sourceAccounts/:sourceAccountId/transfers", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"

payload = {
    "amount": 800828191,
    "currency": "USD",
    "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers"

payload <- "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/sourceAccounts/:sourceAccountId/transfers') do |req|
  req.body = "{\n  \"amount\": 800828191,\n  \"currency\": \"USD\",\n  \"toSourceAccountId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers";

    let payload = json!({
        "amount": 800828191,
        "currency": "USD",
        "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers \
  --header 'content-type: application/json' \
  --data '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
echo '{
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}' |  \
  http POST {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": 800828191,\n  "currency": "USD",\n  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"\n}' \
  --output-document \
  - {{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": 800828191,
  "currency": "USD",
  "toSourceAccountId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/sourceAccounts/:sourceAccountId/transfers")! 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()
POST Resend a token
{{baseUrl}}/v2/users/:userId/tokens
QUERY PARAMS

userId
BODY json

{
  "tokenType": "",
  "verificationCode": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/tokens");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/tokens" {:content-type :json
                                                                    :form-params {:tokenType "INVITE_MFA_USER"
                                                                                  :verificationCode "123456"}})
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/tokens"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/tokens"),
    Content = new StringContent("{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/tokens");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/tokens"

	payload := strings.NewReader("{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}")

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

	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))

}
POST /baseUrl/v2/users/:userId/tokens HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/tokens")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/tokens"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/tokens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/tokens")
  .header("content-type", "application/json")
  .body("{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}")
  .asString();
const data = JSON.stringify({
  tokenType: 'INVITE_MFA_USER',
  verificationCode: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/tokens');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/tokens',
  headers: {'content-type': 'application/json'},
  data: {tokenType: 'INVITE_MFA_USER', verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/tokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tokenType":"INVITE_MFA_USER","verificationCode":"123456"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/tokens',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tokenType": "INVITE_MFA_USER",\n  "verificationCode": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/tokens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/tokens',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({tokenType: 'INVITE_MFA_USER', verificationCode: '123456'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/tokens',
  headers: {'content-type': 'application/json'},
  body: {tokenType: 'INVITE_MFA_USER', verificationCode: '123456'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/tokens');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tokenType: 'INVITE_MFA_USER',
  verificationCode: '123456'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/tokens',
  headers: {'content-type': 'application/json'},
  data: {tokenType: 'INVITE_MFA_USER', verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/tokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tokenType":"INVITE_MFA_USER","verificationCode":"123456"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tokenType": @"INVITE_MFA_USER",
                              @"verificationCode": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/tokens"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/tokens" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/tokens",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'tokenType' => 'INVITE_MFA_USER',
    'verificationCode' => '123456'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/tokens', [
  'body' => '{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/tokens');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tokenType' => 'INVITE_MFA_USER',
  'verificationCode' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'tokenType' => 'INVITE_MFA_USER',
  'verificationCode' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/:userId/tokens');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/tokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/:userId/tokens", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/tokens"

payload = {
    "tokenType": "INVITE_MFA_USER",
    "verificationCode": "123456"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/tokens"

payload <- "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/tokens")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/:userId/tokens') do |req|
  req.body = "{\n  \"tokenType\": \"INVITE_MFA_USER\",\n  \"verificationCode\": \"123456\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/tokens";

    let payload = json!({
        "tokenType": "INVITE_MFA_USER",
        "verificationCode": "123456"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/tokens \
  --header 'content-type: application/json' \
  --data '{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}'
echo '{
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
}' |  \
  http POST {{baseUrl}}/v2/users/:userId/tokens \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tokenType": "INVITE_MFA_USER",\n  "verificationCode": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/tokens
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "tokenType": "INVITE_MFA_USER",
  "verificationCode": "123456"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/tokens")! 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()
DELETE Delete a User
{{baseUrl}}/v2/users/:userId
QUERY PARAMS

userId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/users/:userId")
require "http/client"

url = "{{baseUrl}}/v2/users/:userId"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId"

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

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

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

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

}
DELETE /baseUrl/v2/users/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/users/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v2/users/:userId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v2/users/:userId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/users/:userId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/users/:userId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/v2/users/:userId');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/:userId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/users/:userId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/users/:userId') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request DELETE \
  --url {{baseUrl}}/v2/users/:userId
http DELETE {{baseUrl}}/v2/users/:userId
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/users/:userId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()
POST Disable a User
{{baseUrl}}/v2/users/:userId/disable
QUERY PARAMS

userId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/disable");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/disable")
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/disable"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/disable"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/disable");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/disable"

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

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

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

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

}
POST /baseUrl/v2/users/:userId/disable HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/disable")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/disable"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/disable")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/disable")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/disable');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/disable'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/disable';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/disable',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/disable")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/disable',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/disable'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/disable');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/disable'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/disable';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/disable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/disable" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/disable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/disable');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/disable');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/:userId/disable');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/disable' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/disable' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/users/:userId/disable")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/disable"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/disable"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/disable")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/users/:userId/disable') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/disable";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/disable
http POST {{baseUrl}}/v2/users/:userId/disable
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/disable
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/disable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
POST Enable a User
{{baseUrl}}/v2/users/:userId/enable
QUERY PARAMS

userId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/enable");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/enable")
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/enable"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/enable"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/enable");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/enable"

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

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

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

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

}
POST /baseUrl/v2/users/:userId/enable HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/enable")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/enable"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/enable")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/enable")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/enable');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/enable'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/enable';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/enable',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/enable")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/enable',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/enable'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/enable');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/enable'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/enable';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/enable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/enable" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/enable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/enable');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/enable');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/:userId/enable');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/enable' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/enable' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/users/:userId/enable")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/enable"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/enable"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/enable")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/users/:userId/enable') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/enable";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/enable
http POST {{baseUrl}}/v2/users/:userId/enable
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/enable
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/enable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
GET Get Self
{{baseUrl}}/v2/users/self
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/self");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/users/self")
require "http/client"

url = "{{baseUrl}}/v2/users/self"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/users/self"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/self");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/self"

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

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

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

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

}
GET /baseUrl/v2/users/self HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/users/self")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/self"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/self")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/users/self")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/users/self');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/self'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/self';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/self',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/self")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/self',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/self'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/users/self');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/self'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/self';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/self"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/self" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/self",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/users/self');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/self');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/self');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/self' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/self' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/users/self")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/self"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/self"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/self")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/users/self') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/self";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/users/self
http GET {{baseUrl}}/v2/users/self
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/users/self
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/self")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "companyName": "Acme Corp",
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "id": "8bbf301c-948f-4445-b411-357eec53e441",
  "lastName": "Doe",
  "lockedOut": true,
  "lockedOutTimestamp": "2000-01-23T04:56:07.000+00:00",
  "mfaStatus": "REGISTERED",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "status": "ENABLED",
  "userType": "PAYOR"
}
GET Get User
{{baseUrl}}/v2/users/:userId
QUERY PARAMS

userId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/users/:userId")
require "http/client"

url = "{{baseUrl}}/v2/users/:userId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId"

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

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

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

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

}
GET /baseUrl/v2/users/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/users/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/users/:userId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/users/:userId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/:userId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/users/:userId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/users/:userId');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/:userId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/users/:userId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/users/:userId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/users/:userId
http GET {{baseUrl}}/v2/users/:userId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/users/:userId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "companyName": "Acme Corp",
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "id": "8bbf301c-948f-4445-b411-357eec53e441",
  "lastName": "Doe",
  "lockedOut": true,
  "lockedOutTimestamp": "2000-01-23T04:56:07.000+00:00",
  "mfaStatus": "REGISTERED",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "status": "ENABLED",
  "userType": "PAYOR"
}
POST Invite a User
{{baseUrl}}/v2/users/invite
BODY json

{
  "email": "",
  "entityId": "",
  "firstName": "",
  "lastName": "",
  "mfaType": "",
  "primaryContactNumber": "",
  "roles": [],
  "secondaryContactNumber": "",
  "smsNumber": "",
  "userType": "",
  "verificationCode": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/invite");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/invite" {:content-type :json
                                                            :form-params {:email "foo@example.com"
                                                                          :entityId "7fffa261-ac68-49e6-b605-d24a444d9206"
                                                                          :firstName "John"
                                                                          :lastName "Doe"
                                                                          :mfaType "TOTP"
                                                                          :primaryContactNumber "11235555555"
                                                                          :roles ["velo.payor.admin"]
                                                                          :secondaryContactNumber "11235555550"
                                                                          :smsNumber "11235555555"
                                                                          :userType "PAYEE"
                                                                          :verificationCode "123456"}})
require "http/client"

url = "{{baseUrl}}/v2/users/invite"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/invite"),
    Content = new StringContent("{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/invite");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/invite"

	payload := strings.NewReader("{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}")

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

	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))

}
POST /baseUrl/v2/users/invite HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 361

{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/invite")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/invite"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/invite")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}")
  .asString();
const data = JSON.stringify({
  email: 'foo@example.com',
  entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  roles: [
    'velo.payor.admin'
  ],
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  userType: 'PAYEE',
  verificationCode: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/invite');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/invite',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    roles: ['velo.payor.admin'],
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    userType: 'PAYEE',
    verificationCode: '123456'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","entityId":"7fffa261-ac68-49e6-b605-d24a444d9206","firstName":"John","lastName":"Doe","mfaType":"TOTP","primaryContactNumber":"11235555555","roles":["velo.payor.admin"],"secondaryContactNumber":"11235555550","smsNumber":"11235555555","userType":"PAYEE","verificationCode":"123456"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/invite',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "foo@example.com",\n  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",\n  "firstName": "John",\n  "lastName": "Doe",\n  "mfaType": "TOTP",\n  "primaryContactNumber": "11235555555",\n  "roles": [\n    "velo.payor.admin"\n  ],\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555",\n  "userType": "PAYEE",\n  "verificationCode": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/invite")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/invite',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  email: 'foo@example.com',
  entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  roles: ['velo.payor.admin'],
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  userType: 'PAYEE',
  verificationCode: '123456'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/invite',
  headers: {'content-type': 'application/json'},
  body: {
    email: 'foo@example.com',
    entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    roles: ['velo.payor.admin'],
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    userType: 'PAYEE',
    verificationCode: '123456'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/invite');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: 'foo@example.com',
  entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  roles: [
    'velo.payor.admin'
  ],
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  userType: 'PAYEE',
  verificationCode: '123456'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/invite',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    entityId: '7fffa261-ac68-49e6-b605-d24a444d9206',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    roles: ['velo.payor.admin'],
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    userType: 'PAYEE',
    verificationCode: '123456'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/invite';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","entityId":"7fffa261-ac68-49e6-b605-d24a444d9206","firstName":"John","lastName":"Doe","mfaType":"TOTP","primaryContactNumber":"11235555555","roles":["velo.payor.admin"],"secondaryContactNumber":"11235555550","smsNumber":"11235555555","userType":"PAYEE","verificationCode":"123456"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"foo@example.com",
                              @"entityId": @"7fffa261-ac68-49e6-b605-d24a444d9206",
                              @"firstName": @"John",
                              @"lastName": @"Doe",
                              @"mfaType": @"TOTP",
                              @"primaryContactNumber": @"11235555555",
                              @"roles": @[ @"velo.payor.admin" ],
                              @"secondaryContactNumber": @"11235555550",
                              @"smsNumber": @"11235555555",
                              @"userType": @"PAYEE",
                              @"verificationCode": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/invite"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/invite" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/invite",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'email' => 'foo@example.com',
    'entityId' => '7fffa261-ac68-49e6-b605-d24a444d9206',
    'firstName' => 'John',
    'lastName' => 'Doe',
    'mfaType' => 'TOTP',
    'primaryContactNumber' => '11235555555',
    'roles' => [
        'velo.payor.admin'
    ],
    'secondaryContactNumber' => '11235555550',
    'smsNumber' => '11235555555',
    'userType' => 'PAYEE',
    'verificationCode' => '123456'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/invite', [
  'body' => '{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/invite');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => 'foo@example.com',
  'entityId' => '7fffa261-ac68-49e6-b605-d24a444d9206',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'mfaType' => 'TOTP',
  'primaryContactNumber' => '11235555555',
  'roles' => [
    'velo.payor.admin'
  ],
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555',
  'userType' => 'PAYEE',
  'verificationCode' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'email' => 'foo@example.com',
  'entityId' => '7fffa261-ac68-49e6-b605-d24a444d9206',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'mfaType' => 'TOTP',
  'primaryContactNumber' => '11235555555',
  'roles' => [
    'velo.payor.admin'
  ],
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555',
  'userType' => 'PAYEE',
  'verificationCode' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/invite');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/invite' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/invite", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/invite"

payload = {
    "email": "foo@example.com",
    "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
    "firstName": "John",
    "lastName": "Doe",
    "mfaType": "TOTP",
    "primaryContactNumber": "11235555555",
    "roles": ["velo.payor.admin"],
    "secondaryContactNumber": "11235555550",
    "smsNumber": "11235555555",
    "userType": "PAYEE",
    "verificationCode": "123456"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/invite"

payload <- "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/invite")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/invite') do |req|
  req.body = "{\n  \"email\": \"foo@example.com\",\n  \"entityId\": \"7fffa261-ac68-49e6-b605-d24a444d9206\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"roles\": [\n    \"velo.payor.admin\"\n  ],\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"userType\": \"PAYEE\",\n  \"verificationCode\": \"123456\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/invite";

    let payload = json!({
        "email": "foo@example.com",
        "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
        "firstName": "John",
        "lastName": "Doe",
        "mfaType": "TOTP",
        "primaryContactNumber": "11235555555",
        "roles": ("velo.payor.admin"),
        "secondaryContactNumber": "11235555550",
        "smsNumber": "11235555555",
        "userType": "PAYEE",
        "verificationCode": "123456"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/invite \
  --header 'content-type: application/json' \
  --data '{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}'
echo '{
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": [
    "velo.payor.admin"
  ],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
}' |  \
  http POST {{baseUrl}}/v2/users/invite \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "foo@example.com",\n  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",\n  "firstName": "John",\n  "lastName": "Doe",\n  "mfaType": "TOTP",\n  "primaryContactNumber": "11235555555",\n  "roles": [\n    "velo.payor.admin"\n  ],\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555",\n  "userType": "PAYEE",\n  "verificationCode": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/invite
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "foo@example.com",
  "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "roles": ["velo.payor.admin"],
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "userType": "PAYEE",
  "verificationCode": "123456"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/invite")! 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()
GET List Users
{{baseUrl}}/v2/users
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/users")
require "http/client"

url = "{{baseUrl}}/v2/users"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users"

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

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

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

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

}
GET /baseUrl/v2/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v2/users")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/users');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v2/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v2/users');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/users') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v2/users
http GET {{baseUrl}}/v2/users
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/users
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "companyName": "Acme Corp",
      "email": "foo@example.com",
      "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
      "firstName": "John",
      "id": "8bbf301c-948f-4445-b411-357eec53e441",
      "lastName": "Doe",
      "lockedOut": true,
      "lockedOutTimestamp": "2000-01-23T04:56:07.000+00:00",
      "mfaStatus": "REGISTERED",
      "mfaType": "TOTP",
      "primaryContactNumber": "11235555555",
      "roles": [
        "payor.admin"
      ],
      "secondaryContactNumber": "11235555550",
      "smsNumber": "11235555555",
      "status": "ENABLED",
      "userType": "PAYOR"
    },
    {
      "companyName": "Acme Corp",
      "email": "foo@example.com",
      "entityId": "7fffa261-ac68-49e6-b605-d24a444d9206",
      "firstName": "John",
      "id": "8bbf301c-948f-4445-b411-357eec53e441",
      "lastName": "Doe",
      "lockedOut": true,
      "lockedOutTimestamp": "2000-01-23T04:56:07.000+00:00",
      "mfaStatus": "REGISTERED",
      "mfaType": "TOTP",
      "primaryContactNumber": "11235555555",
      "roles": [
        "payor.admin"
      ],
      "secondaryContactNumber": "11235555550",
      "smsNumber": "11235555555",
      "status": "ENABLED",
      "userType": "PAYOR"
    }
  ],
  "links": [
    {
      "href": "https://api.sandbox.velopayments.com/v2/users??type=PAYOR&page=1&pageSize=10",
      "rel": "first"
    },
    {
      "href": "https://api.sandbox.velopayments.com/v2/users??type=PAYOR&page=1&pageSize=10",
      "rel": "first"
    }
  ],
  "page": {
    "numberOfElements": 12,
    "page": 1,
    "pageSize": 25,
    "totalElements": 33,
    "totalPages": 2
  }
}
POST Register SMS Number
{{baseUrl}}/v2/users/registration/sms
BODY json

{
  "smsNumber": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/registration/sms");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"smsNumber\": \"11235555555\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/registration/sms" {:content-type :json
                                                                      :form-params {:smsNumber "11235555555"}})
require "http/client"

url = "{{baseUrl}}/v2/users/registration/sms"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"smsNumber\": \"11235555555\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/registration/sms"),
    Content = new StringContent("{\n  \"smsNumber\": \"11235555555\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/registration/sms");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"smsNumber\": \"11235555555\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/registration/sms"

	payload := strings.NewReader("{\n  \"smsNumber\": \"11235555555\"\n}")

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

	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))

}
POST /baseUrl/v2/users/registration/sms HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "smsNumber": "11235555555"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/registration/sms")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"smsNumber\": \"11235555555\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/registration/sms"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"smsNumber\": \"11235555555\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"smsNumber\": \"11235555555\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/registration/sms")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/registration/sms")
  .header("content-type", "application/json")
  .body("{\n  \"smsNumber\": \"11235555555\"\n}")
  .asString();
const data = JSON.stringify({
  smsNumber: '11235555555'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/registration/sms');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/registration/sms',
  headers: {'content-type': 'application/json'},
  data: {smsNumber: '11235555555'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/registration/sms';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"smsNumber":"11235555555"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/registration/sms',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "smsNumber": "11235555555"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"smsNumber\": \"11235555555\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/registration/sms")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/registration/sms',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({smsNumber: '11235555555'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/registration/sms',
  headers: {'content-type': 'application/json'},
  body: {smsNumber: '11235555555'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/registration/sms');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  smsNumber: '11235555555'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/registration/sms',
  headers: {'content-type': 'application/json'},
  data: {smsNumber: '11235555555'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/registration/sms';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"smsNumber":"11235555555"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"smsNumber": @"11235555555" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/registration/sms"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/registration/sms" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"smsNumber\": \"11235555555\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/registration/sms",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'smsNumber' => '11235555555'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/registration/sms', [
  'body' => '{
  "smsNumber": "11235555555"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/registration/sms');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'smsNumber' => '11235555555'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'smsNumber' => '11235555555'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/registration/sms');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/registration/sms' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "smsNumber": "11235555555"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/registration/sms' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "smsNumber": "11235555555"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"smsNumber\": \"11235555555\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/registration/sms", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/registration/sms"

payload = { "smsNumber": "11235555555" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/registration/sms"

payload <- "{\n  \"smsNumber\": \"11235555555\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/registration/sms")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"smsNumber\": \"11235555555\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/registration/sms') do |req|
  req.body = "{\n  \"smsNumber\": \"11235555555\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/registration/sms";

    let payload = json!({"smsNumber": "11235555555"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/registration/sms \
  --header 'content-type: application/json' \
  --data '{
  "smsNumber": "11235555555"
}'
echo '{
  "smsNumber": "11235555555"
}' |  \
  http POST {{baseUrl}}/v2/users/registration/sms \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "smsNumber": "11235555555"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/registration/sms
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["smsNumber": "11235555555"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/registration/sms")! 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()
POST Unlock a User
{{baseUrl}}/v2/users/:userId/unlock
QUERY PARAMS

userId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/unlock");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/unlock")
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/unlock"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/unlock"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/unlock");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/unlock"

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

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

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

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

}
POST /baseUrl/v2/users/:userId/unlock HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/unlock")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/unlock"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/unlock")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/unlock")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/unlock');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/unlock'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/unlock';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/unlock',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/unlock")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/unlock',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/unlock'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/unlock');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v2/users/:userId/unlock'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/unlock';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/unlock"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/unlock" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/unlock",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/unlock');

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/unlock');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v2/users/:userId/unlock');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/unlock' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/unlock' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/users/:userId/unlock")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/unlock"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/unlock"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/unlock")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/users/:userId/unlock') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/unlock";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/unlock
http POST {{baseUrl}}/v2/users/:userId/unlock
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/unlock
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/unlock")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
POST Unregister MFA for Self
{{baseUrl}}/v2/users/self/mfa/unregister
BODY json

{
  "mfaType": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/self/mfa/unregister");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"mfaType\": \"TOTP\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/self/mfa/unregister" {:content-type :json
                                                                         :form-params {:mfaType "TOTP"}})
require "http/client"

url = "{{baseUrl}}/v2/users/self/mfa/unregister"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"mfaType\": \"TOTP\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/self/mfa/unregister"),
    Content = new StringContent("{\n  \"mfaType\": \"TOTP\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/self/mfa/unregister");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"mfaType\": \"TOTP\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/self/mfa/unregister"

	payload := strings.NewReader("{\n  \"mfaType\": \"TOTP\"\n}")

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

	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))

}
POST /baseUrl/v2/users/self/mfa/unregister HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "mfaType": "TOTP"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/self/mfa/unregister")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"mfaType\": \"TOTP\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/self/mfa/unregister"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"mfaType\": \"TOTP\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"mfaType\": \"TOTP\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/self/mfa/unregister")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/self/mfa/unregister")
  .header("content-type", "application/json")
  .body("{\n  \"mfaType\": \"TOTP\"\n}")
  .asString();
const data = JSON.stringify({
  mfaType: 'TOTP'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/self/mfa/unregister');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/mfa/unregister',
  headers: {'content-type': 'application/json'},
  data: {mfaType: 'TOTP'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/self/mfa/unregister';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mfaType":"TOTP"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/self/mfa/unregister',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "mfaType": "TOTP"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"mfaType\": \"TOTP\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/self/mfa/unregister")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/self/mfa/unregister',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({mfaType: 'TOTP'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/mfa/unregister',
  headers: {'content-type': 'application/json'},
  body: {mfaType: 'TOTP'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/self/mfa/unregister');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  mfaType: 'TOTP'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/mfa/unregister',
  headers: {'content-type': 'application/json'},
  data: {mfaType: 'TOTP'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/self/mfa/unregister';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mfaType":"TOTP"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"mfaType": @"TOTP" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/self/mfa/unregister"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/self/mfa/unregister" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"mfaType\": \"TOTP\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/self/mfa/unregister",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'mfaType' => 'TOTP'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/self/mfa/unregister', [
  'body' => '{
  "mfaType": "TOTP"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/self/mfa/unregister');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'mfaType' => 'TOTP'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'mfaType' => 'TOTP'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/self/mfa/unregister');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/self/mfa/unregister' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mfaType": "TOTP"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/self/mfa/unregister' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mfaType": "TOTP"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"mfaType\": \"TOTP\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/self/mfa/unregister", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/self/mfa/unregister"

payload = { "mfaType": "TOTP" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/self/mfa/unregister"

payload <- "{\n  \"mfaType\": \"TOTP\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/self/mfa/unregister")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"mfaType\": \"TOTP\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/self/mfa/unregister') do |req|
  req.body = "{\n  \"mfaType\": \"TOTP\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/self/mfa/unregister";

    let payload = json!({"mfaType": "TOTP"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/self/mfa/unregister \
  --header 'content-type: application/json' \
  --data '{
  "mfaType": "TOTP"
}'
echo '{
  "mfaType": "TOTP"
}' |  \
  http POST {{baseUrl}}/v2/users/self/mfa/unregister \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "mfaType": "TOTP"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/self/mfa/unregister
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["mfaType": "TOTP"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/self/mfa/unregister")! 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()
POST Unregister MFA for the user
{{baseUrl}}/v2/users/:userId/mfa/unregister
QUERY PARAMS

userId
BODY json

{
  "mfaType": "",
  "verificationCode": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/mfa/unregister");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/mfa/unregister" {:content-type :json
                                                                            :form-params {:mfaType "TOTP"
                                                                                          :verificationCode "123456"}})
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/mfa/unregister"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/mfa/unregister"),
    Content = new StringContent("{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/mfa/unregister");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/mfa/unregister"

	payload := strings.NewReader("{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}")

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

	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))

}
POST /baseUrl/v2/users/:userId/mfa/unregister HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/mfa/unregister")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/mfa/unregister"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/mfa/unregister")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/mfa/unregister")
  .header("content-type", "application/json")
  .body("{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}")
  .asString();
const data = JSON.stringify({
  mfaType: 'TOTP',
  verificationCode: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/mfa/unregister');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/mfa/unregister',
  headers: {'content-type': 'application/json'},
  data: {mfaType: 'TOTP', verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/mfa/unregister';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mfaType":"TOTP","verificationCode":"123456"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/mfa/unregister',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "mfaType": "TOTP",\n  "verificationCode": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/mfa/unregister")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/mfa/unregister',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({mfaType: 'TOTP', verificationCode: '123456'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/mfa/unregister',
  headers: {'content-type': 'application/json'},
  body: {mfaType: 'TOTP', verificationCode: '123456'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/mfa/unregister');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  mfaType: 'TOTP',
  verificationCode: '123456'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/mfa/unregister',
  headers: {'content-type': 'application/json'},
  data: {mfaType: 'TOTP', verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/mfa/unregister';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mfaType":"TOTP","verificationCode":"123456"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"mfaType": @"TOTP",
                              @"verificationCode": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/mfa/unregister"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/mfa/unregister" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/mfa/unregister",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'mfaType' => 'TOTP',
    'verificationCode' => '123456'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/mfa/unregister', [
  'body' => '{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/mfa/unregister');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'mfaType' => 'TOTP',
  'verificationCode' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'mfaType' => 'TOTP',
  'verificationCode' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/:userId/mfa/unregister');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/mfa/unregister' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/mfa/unregister' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/:userId/mfa/unregister", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/mfa/unregister"

payload = {
    "mfaType": "TOTP",
    "verificationCode": "123456"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/mfa/unregister"

payload <- "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/mfa/unregister")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/:userId/mfa/unregister') do |req|
  req.body = "{\n  \"mfaType\": \"TOTP\",\n  \"verificationCode\": \"123456\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/mfa/unregister";

    let payload = json!({
        "mfaType": "TOTP",
        "verificationCode": "123456"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/mfa/unregister \
  --header 'content-type: application/json' \
  --data '{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}'
echo '{
  "mfaType": "TOTP",
  "verificationCode": "123456"
}' |  \
  http POST {{baseUrl}}/v2/users/:userId/mfa/unregister \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "mfaType": "TOTP",\n  "verificationCode": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/mfa/unregister
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "mfaType": "TOTP",
  "verificationCode": "123456"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/mfa/unregister")! 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()
POST Update Password for self
{{baseUrl}}/v2/users/self/password
BODY json

{
  "newPassword": "",
  "oldPassword": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/self/password");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/self/password" {:content-type :json
                                                                   :form-params {:newPassword "My_new_password"
                                                                                 :oldPassword "My_current_password"}})
require "http/client"

url = "{{baseUrl}}/v2/users/self/password"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/self/password"),
    Content = new StringContent("{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/self/password");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/self/password"

	payload := strings.NewReader("{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}")

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

	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))

}
POST /baseUrl/v2/users/self/password HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/self/password")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/self/password"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/self/password")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/self/password")
  .header("content-type", "application/json")
  .body("{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}")
  .asString();
const data = JSON.stringify({
  newPassword: 'My_new_password',
  oldPassword: 'My_current_password'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/self/password');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password',
  headers: {'content-type': 'application/json'},
  data: {newPassword: 'My_new_password', oldPassword: 'My_current_password'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/self/password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPassword":"My_new_password","oldPassword":"My_current_password"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/self/password',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "newPassword": "My_new_password",\n  "oldPassword": "My_current_password"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/self/password")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/self/password',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({newPassword: 'My_new_password', oldPassword: 'My_current_password'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password',
  headers: {'content-type': 'application/json'},
  body: {newPassword: 'My_new_password', oldPassword: 'My_current_password'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/self/password');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  newPassword: 'My_new_password',
  oldPassword: 'My_current_password'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password',
  headers: {'content-type': 'application/json'},
  data: {newPassword: 'My_new_password', oldPassword: 'My_current_password'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/self/password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPassword":"My_new_password","oldPassword":"My_current_password"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"newPassword": @"My_new_password",
                              @"oldPassword": @"My_current_password" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/self/password"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/self/password" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/self/password",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'newPassword' => 'My_new_password',
    'oldPassword' => 'My_current_password'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/self/password', [
  'body' => '{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/self/password');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'newPassword' => 'My_new_password',
  'oldPassword' => 'My_current_password'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'newPassword' => 'My_new_password',
  'oldPassword' => 'My_current_password'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/self/password');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/self/password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/self/password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/self/password", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/self/password"

payload = {
    "newPassword": "My_new_password",
    "oldPassword": "My_current_password"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/self/password"

payload <- "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/self/password")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/self/password') do |req|
  req.body = "{\n  \"newPassword\": \"My_new_password\",\n  \"oldPassword\": \"My_current_password\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/self/password";

    let payload = json!({
        "newPassword": "My_new_password",
        "oldPassword": "My_current_password"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/self/password \
  --header 'content-type: application/json' \
  --data '{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}'
echo '{
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
}' |  \
  http POST {{baseUrl}}/v2/users/self/password \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "newPassword": "My_new_password",\n  "oldPassword": "My_current_password"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/self/password
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "newPassword": "My_new_password",
  "oldPassword": "My_current_password"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/self/password")! 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()
POST Update User Details for self
{{baseUrl}}/v2/users/self/userDetailsUpdate
BODY json

{
  "email": "",
  "firstName": "",
  "lastName": "",
  "primaryContactNumber": "",
  "secondaryContactNumber": "",
  "smsNumber": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/self/userDetailsUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/self/userDetailsUpdate" {:content-type :json
                                                                            :form-params {:email "foo@example.com"
                                                                                          :firstName "John"
                                                                                          :lastName "Doe"
                                                                                          :primaryContactNumber "11235555555"
                                                                                          :secondaryContactNumber "11235555550"
                                                                                          :smsNumber "11235555555"}})
require "http/client"

url = "{{baseUrl}}/v2/users/self/userDetailsUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/self/userDetailsUpdate"),
    Content = new StringContent("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/self/userDetailsUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/self/userDetailsUpdate"

	payload := strings.NewReader("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}")

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

	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))

}
POST /baseUrl/v2/users/self/userDetailsUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 190

{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/self/userDetailsUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/self/userDetailsUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/self/userDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/self/userDetailsUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}")
  .asString();
const data = JSON.stringify({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/self/userDetailsUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/self/userDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","firstName":"John","lastName":"Doe","primaryContactNumber":"11235555555","secondaryContactNumber":"11235555550","smsNumber":"11235555555"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/self/userDetailsUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "foo@example.com",\n  "firstName": "John",\n  "lastName": "Doe",\n  "primaryContactNumber": "11235555555",\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/self/userDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/self/userDetailsUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  body: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/self/userDetailsUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/self/userDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","firstName":"John","lastName":"Doe","primaryContactNumber":"11235555555","secondaryContactNumber":"11235555550","smsNumber":"11235555555"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"foo@example.com",
                              @"firstName": @"John",
                              @"lastName": @"Doe",
                              @"primaryContactNumber": @"11235555555",
                              @"secondaryContactNumber": @"11235555550",
                              @"smsNumber": @"11235555555" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/self/userDetailsUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/self/userDetailsUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/self/userDetailsUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'email' => 'foo@example.com',
    'firstName' => 'John',
    'lastName' => 'Doe',
    'primaryContactNumber' => '11235555555',
    'secondaryContactNumber' => '11235555550',
    'smsNumber' => '11235555555'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/self/userDetailsUpdate', [
  'body' => '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/self/userDetailsUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => 'foo@example.com',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'primaryContactNumber' => '11235555555',
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'email' => 'foo@example.com',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'primaryContactNumber' => '11235555555',
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/self/userDetailsUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/self/userDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/self/userDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/self/userDetailsUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/self/userDetailsUpdate"

payload = {
    "email": "foo@example.com",
    "firstName": "John",
    "lastName": "Doe",
    "primaryContactNumber": "11235555555",
    "secondaryContactNumber": "11235555550",
    "smsNumber": "11235555555"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/self/userDetailsUpdate"

payload <- "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/self/userDetailsUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/self/userDetailsUpdate') do |req|
  req.body = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/self/userDetailsUpdate";

    let payload = json!({
        "email": "foo@example.com",
        "firstName": "John",
        "lastName": "Doe",
        "primaryContactNumber": "11235555555",
        "secondaryContactNumber": "11235555550",
        "smsNumber": "11235555555"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/self/userDetailsUpdate \
  --header 'content-type: application/json' \
  --data '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}'
echo '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
}' |  \
  http POST {{baseUrl}}/v2/users/self/userDetailsUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "foo@example.com",\n  "firstName": "John",\n  "lastName": "Doe",\n  "primaryContactNumber": "11235555555",\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/self/userDetailsUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/self/userDetailsUpdate")! 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()
POST Update User Details
{{baseUrl}}/v2/users/:userId/userDetailsUpdate
QUERY PARAMS

userId
BODY json

{
  "email": "",
  "firstName": "",
  "lastName": "",
  "mfaType": "",
  "primaryContactNumber": "",
  "secondaryContactNumber": "",
  "smsNumber": "",
  "verificationCode": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/userDetailsUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/userDetailsUpdate" {:content-type :json
                                                                               :form-params {:email "foo@example.com"
                                                                                             :firstName "John"
                                                                                             :lastName "Doe"
                                                                                             :mfaType "TOTP"
                                                                                             :primaryContactNumber "11235555555"
                                                                                             :secondaryContactNumber "11235555550"
                                                                                             :smsNumber "11235555555"
                                                                                             :verificationCode "123456"}})
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/userDetailsUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/userDetailsUpdate"),
    Content = new StringContent("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/userDetailsUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/userDetailsUpdate"

	payload := strings.NewReader("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}")

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

	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))

}
POST /baseUrl/v2/users/:userId/userDetailsUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 243

{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/userDetailsUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/userDetailsUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/userDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/userDetailsUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}")
  .asString();
const data = JSON.stringify({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  verificationCode: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/userDetailsUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    verificationCode: '123456'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/userDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","firstName":"John","lastName":"Doe","mfaType":"TOTP","primaryContactNumber":"11235555555","secondaryContactNumber":"11235555550","smsNumber":"11235555555","verificationCode":"123456"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/userDetailsUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "foo@example.com",\n  "firstName": "John",\n  "lastName": "Doe",\n  "mfaType": "TOTP",\n  "primaryContactNumber": "11235555555",\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555",\n  "verificationCode": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/userDetailsUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/userDetailsUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  verificationCode: '123456'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  body: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    verificationCode: '123456'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/userDetailsUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: 'foo@example.com',
  firstName: 'John',
  lastName: 'Doe',
  mfaType: 'TOTP',
  primaryContactNumber: '11235555555',
  secondaryContactNumber: '11235555550',
  smsNumber: '11235555555',
  verificationCode: '123456'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/userDetailsUpdate',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'foo@example.com',
    firstName: 'John',
    lastName: 'Doe',
    mfaType: 'TOTP',
    primaryContactNumber: '11235555555',
    secondaryContactNumber: '11235555550',
    smsNumber: '11235555555',
    verificationCode: '123456'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/userDetailsUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"foo@example.com","firstName":"John","lastName":"Doe","mfaType":"TOTP","primaryContactNumber":"11235555555","secondaryContactNumber":"11235555550","smsNumber":"11235555555","verificationCode":"123456"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"foo@example.com",
                              @"firstName": @"John",
                              @"lastName": @"Doe",
                              @"mfaType": @"TOTP",
                              @"primaryContactNumber": @"11235555555",
                              @"secondaryContactNumber": @"11235555550",
                              @"smsNumber": @"11235555555",
                              @"verificationCode": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/userDetailsUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/userDetailsUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/userDetailsUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'email' => 'foo@example.com',
    'firstName' => 'John',
    'lastName' => 'Doe',
    'mfaType' => 'TOTP',
    'primaryContactNumber' => '11235555555',
    'secondaryContactNumber' => '11235555550',
    'smsNumber' => '11235555555',
    'verificationCode' => '123456'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/userDetailsUpdate', [
  'body' => '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/userDetailsUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => 'foo@example.com',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'mfaType' => 'TOTP',
  'primaryContactNumber' => '11235555555',
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555',
  'verificationCode' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'email' => 'foo@example.com',
  'firstName' => 'John',
  'lastName' => 'Doe',
  'mfaType' => 'TOTP',
  'primaryContactNumber' => '11235555555',
  'secondaryContactNumber' => '11235555550',
  'smsNumber' => '11235555555',
  'verificationCode' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/:userId/userDetailsUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/userDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/userDetailsUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/:userId/userDetailsUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/userDetailsUpdate"

payload = {
    "email": "foo@example.com",
    "firstName": "John",
    "lastName": "Doe",
    "mfaType": "TOTP",
    "primaryContactNumber": "11235555555",
    "secondaryContactNumber": "11235555550",
    "smsNumber": "11235555555",
    "verificationCode": "123456"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/userDetailsUpdate"

payload <- "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/userDetailsUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/:userId/userDetailsUpdate') do |req|
  req.body = "{\n  \"email\": \"foo@example.com\",\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"mfaType\": \"TOTP\",\n  \"primaryContactNumber\": \"11235555555\",\n  \"secondaryContactNumber\": \"11235555550\",\n  \"smsNumber\": \"11235555555\",\n  \"verificationCode\": \"123456\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/userDetailsUpdate";

    let payload = json!({
        "email": "foo@example.com",
        "firstName": "John",
        "lastName": "Doe",
        "mfaType": "TOTP",
        "primaryContactNumber": "11235555555",
        "secondaryContactNumber": "11235555550",
        "smsNumber": "11235555555",
        "verificationCode": "123456"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/userDetailsUpdate \
  --header 'content-type: application/json' \
  --data '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}'
echo '{
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
}' |  \
  http POST {{baseUrl}}/v2/users/:userId/userDetailsUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "foo@example.com",\n  "firstName": "John",\n  "lastName": "Doe",\n  "mfaType": "TOTP",\n  "primaryContactNumber": "11235555555",\n  "secondaryContactNumber": "11235555550",\n  "smsNumber": "11235555555",\n  "verificationCode": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/userDetailsUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "foo@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "mfaType": "TOTP",
  "primaryContactNumber": "11235555555",
  "secondaryContactNumber": "11235555550",
  "smsNumber": "11235555555",
  "verificationCode": "123456"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/userDetailsUpdate")! 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()
POST Update User Role
{{baseUrl}}/v2/users/:userId/roleUpdate
QUERY PARAMS

userId
BODY json

{
  "roles": [],
  "verificationCode": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:userId/roleUpdate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/:userId/roleUpdate" {:content-type :json
                                                                        :form-params {:roles ["payor.admin"]
                                                                                      :verificationCode "123456"}})
require "http/client"

url = "{{baseUrl}}/v2/users/:userId/roleUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:userId/roleUpdate"),
    Content = new StringContent("{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/:userId/roleUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/:userId/roleUpdate"

	payload := strings.NewReader("{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}")

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

	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))

}
POST /baseUrl/v2/users/:userId/roleUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/:userId/roleUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:userId/roleUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/roleUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/:userId/roleUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}")
  .asString();
const data = JSON.stringify({
  roles: [
    'payor.admin'
  ],
  verificationCode: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/:userId/roleUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/roleUpdate',
  headers: {'content-type': 'application/json'},
  data: {roles: ['payor.admin'], verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/:userId/roleUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roles":["payor.admin"],"verificationCode":"123456"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:userId/roleUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roles": [\n    "payor.admin"\n  ],\n  "verificationCode": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:userId/roleUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:userId/roleUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({roles: ['payor.admin'], verificationCode: '123456'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/roleUpdate',
  headers: {'content-type': 'application/json'},
  body: {roles: ['payor.admin'], verificationCode: '123456'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/:userId/roleUpdate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roles: [
    'payor.admin'
  ],
  verificationCode: '123456'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/:userId/roleUpdate',
  headers: {'content-type': 'application/json'},
  data: {roles: ['payor.admin'], verificationCode: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:userId/roleUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roles":["payor.admin"],"verificationCode":"123456"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"roles": @[ @"payor.admin" ],
                              @"verificationCode": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:userId/roleUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:userId/roleUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/:userId/roleUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'roles' => [
        'payor.admin'
    ],
    'verificationCode' => '123456'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/:userId/roleUpdate', [
  'body' => '{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/:userId/roleUpdate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roles' => [
    'payor.admin'
  ],
  'verificationCode' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'roles' => [
    'payor.admin'
  ],
  'verificationCode' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/:userId/roleUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:userId/roleUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:userId/roleUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/:userId/roleUpdate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/:userId/roleUpdate"

payload = {
    "roles": ["payor.admin"],
    "verificationCode": "123456"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/:userId/roleUpdate"

payload <- "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:userId/roleUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/:userId/roleUpdate') do |req|
  req.body = "{\n  \"roles\": [\n    \"payor.admin\"\n  ],\n  \"verificationCode\": \"123456\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:userId/roleUpdate";

    let payload = json!({
        "roles": ("payor.admin"),
        "verificationCode": "123456"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/:userId/roleUpdate \
  --header 'content-type: application/json' \
  --data '{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}'
echo '{
  "roles": [
    "payor.admin"
  ],
  "verificationCode": "123456"
}' |  \
  http POST {{baseUrl}}/v2/users/:userId/roleUpdate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "roles": [\n    "payor.admin"\n  ],\n  "verificationCode": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/:userId/roleUpdate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roles": ["payor.admin"],
  "verificationCode": "123456"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:userId/roleUpdate")! 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()
POST Validate the proposed password
{{baseUrl}}/v2/users/self/password/validate
BODY json

{
  "password": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/self/password/validate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/users/self/password/validate" {:content-type :json
                                                                            :form-params {:password ""}})
require "http/client"

url = "{{baseUrl}}/v2/users/self/password/validate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"password\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/users/self/password/validate"),
    Content = new StringContent("{\n  \"password\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v2/users/self/password/validate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v2/users/self/password/validate"

	payload := strings.NewReader("{\n  \"password\": \"\"\n}")

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

	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))

}
POST /baseUrl/v2/users/self/password/validate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "password": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/users/self/password/validate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/self/password/validate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"password\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/users/self/password/validate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v2/users/self/password/validate")
  .header("content-type", "application/json")
  .body("{\n  \"password\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/users/self/password/validate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password/validate',
  headers: {'content-type': 'application/json'},
  data: {password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v2/users/self/password/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/self/password/validate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/self/password/validate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/self/password/validate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({password: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password/validate',
  headers: {'content-type': 'application/json'},
  body: {password: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/users/self/password/validate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  password: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/users/self/password/validate',
  headers: {'content-type': 'application/json'},
  data: {password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/self/password/validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/self/password/validate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/self/password/validate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"password\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v2/users/self/password/validate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'password' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v2/users/self/password/validate', [
  'body' => '{
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v2/users/self/password/validate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v2/users/self/password/validate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/self/password/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/self/password/validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"password\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/users/self/password/validate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v2/users/self/password/validate"

payload = { "password": "" }
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v2/users/self/password/validate"

payload <- "{\n  \"password\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/self/password/validate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"password\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v2/users/self/password/validate') do |req|
  req.body = "{\n  \"password\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/self/password/validate";

    let payload = json!({"password": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v2/users/self/password/validate \
  --header 'content-type: application/json' \
  --data '{
  "password": ""
}'
echo '{
  "password": ""
}' |  \
  http POST {{baseUrl}}/v2/users/self/password/validate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/v2/users/self/password/validate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["password": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/self/password/validate")! 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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "score": 2,
  "suggestions": [
    "[password has been used before]",
    "[password has been used before]"
  ],
  "valid": true,
  "warning": "Historic Password"
}
POST Create Webhook
{{baseUrl}}/v1/webhooks
BODY json

{
  "authorizationHeader": "",
  "categories": [],
  "enabled": false,
  "payorId": "",
  "webhookUrl": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/webhooks" {:content-type :json
                                                        :form-params {:authorizationHeader "authorizationHeader"
                                                                      :categories [nil nil]
                                                                      :enabled true
                                                                      :payorId "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
                                                                      :webhookUrl "webhookUrl"}})
require "http/client"

url = "{{baseUrl}}/v1/webhooks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/webhooks"),
    Content = new StringContent("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/webhooks"

	payload := strings.NewReader("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}")

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

	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))

}
POST /baseUrl/v1/webhooks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 194

{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/webhooks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/webhooks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/webhooks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/webhooks")
  .header("content-type", "application/json")
  .body("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}")
  .asString();
const data = JSON.stringify({
  authorizationHeader: 'authorizationHeader',
  categories: [
    null,
    null
  ],
  enabled: true,
  payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  webhookUrl: 'webhookUrl'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/webhooks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    webhookUrl: 'webhookUrl'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationHeader":"authorizationHeader","categories":[null,null],"enabled":true,"payorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91","webhookUrl":"webhookUrl"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizationHeader": "authorizationHeader",\n  "categories": [\n    null,\n    null\n  ],\n  "enabled": true,\n  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",\n  "webhookUrl": "webhookUrl"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/webhooks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/webhooks',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authorizationHeader: 'authorizationHeader',
  categories: [null, null],
  enabled: true,
  payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  webhookUrl: 'webhookUrl'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks',
  headers: {'content-type': 'application/json'},
  body: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    webhookUrl: 'webhookUrl'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/webhooks');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authorizationHeader: 'authorizationHeader',
  categories: [
    null,
    null
  ],
  enabled: true,
  payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  webhookUrl: 'webhookUrl'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    payorId: '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    webhookUrl: 'webhookUrl'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationHeader":"authorizationHeader","categories":[null,null],"enabled":true,"payorId":"046b6c7f-0b8a-43b9-b35d-6489e6daee91","webhookUrl":"webhookUrl"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authorizationHeader": @"authorizationHeader",
                              @"categories": @[ ,  ],
                              @"enabled": @YES,
                              @"payorId": @"046b6c7f-0b8a-43b9-b35d-6489e6daee91",
                              @"webhookUrl": @"webhookUrl" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authorizationHeader' => 'authorizationHeader',
    'categories' => [
        null,
        null
    ],
    'enabled' => null,
    'payorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
    'webhookUrl' => 'webhookUrl'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/webhooks', [
  'body' => '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/webhooks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizationHeader' => 'authorizationHeader',
  'categories' => [
    null,
    null
  ],
  'enabled' => null,
  'payorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  'webhookUrl' => 'webhookUrl'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'authorizationHeader' => 'authorizationHeader',
  'categories' => [
    null,
    null
  ],
  'enabled' => null,
  'payorId' => '046b6c7f-0b8a-43b9-b35d-6489e6daee91',
  'webhookUrl' => 'webhookUrl'
]));
$request->setRequestUrl('{{baseUrl}}/v1/webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/webhooks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/webhooks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/webhooks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/webhooks"

payload = {
    "authorizationHeader": "authorizationHeader",
    "categories": [None, None],
    "enabled": True,
    "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "webhookUrl": "webhookUrl"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/webhooks"

payload <- "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/webhooks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/webhooks') do |req|
  req.body = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"payorId\": \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"webhookUrl\": \"webhookUrl\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/webhooks";

    let payload = json!({
        "authorizationHeader": "authorizationHeader",
        "categories": (json!(null), json!(null)),
        "enabled": true,
        "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
        "webhookUrl": "webhookUrl"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/webhooks \
  --header 'content-type: application/json' \
  --data '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}'
echo '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}' |  \
  http POST {{baseUrl}}/v1/webhooks \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizationHeader": "authorizationHeader",\n  "categories": [\n    null,\n    null\n  ],\n  "enabled": true,\n  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",\n  "webhookUrl": "webhookUrl"\n}' \
  --output-document \
  - {{baseUrl}}/v1/webhooks
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizationHeader": "authorizationHeader",
  "categories": [, ],
  "enabled": true,
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/webhooks")! 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()
GET Get details about the given webhook.
{{baseUrl}}/v1/webhooks/:webhookId
QUERY PARAMS

webhookId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/webhooks/:webhookId");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/webhooks/:webhookId")
require "http/client"

url = "{{baseUrl}}/v1/webhooks/:webhookId"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/webhooks/:webhookId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/webhooks/:webhookId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/webhooks/:webhookId"

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

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

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

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

}
GET /baseUrl/v1/webhooks/:webhookId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/webhooks/:webhookId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/webhooks/:webhookId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/webhooks/:webhookId")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/webhooks/:webhookId');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/webhooks/:webhookId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/webhooks/:webhookId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/webhooks/:webhookId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/webhooks/:webhookId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/webhooks/:webhookId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/webhooks/:webhookId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/webhooks/:webhookId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/webhooks/:webhookId';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/webhooks/:webhookId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/webhooks/:webhookId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/webhooks/:webhookId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/webhooks/:webhookId');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/webhooks/:webhookId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/webhooks/:webhookId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/webhooks/:webhookId' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/webhooks/:webhookId' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/webhooks/:webhookId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/webhooks/:webhookId"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/webhooks/:webhookId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/webhooks/:webhookId")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/webhooks/:webhookId') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/webhooks/:webhookId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url {{baseUrl}}/v1/webhooks/:webhookId
http GET {{baseUrl}}/v1/webhooks/:webhookId
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/webhooks/:webhookId
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/webhooks/:webhookId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookUrl": "webhookUrl"
}
GET List the details about the webhooks for the given payor.
{{baseUrl}}/v1/webhooks
QUERY PARAMS

payorId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/webhooks?payorId=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/webhooks" {:query-params {:payorId ""}})
require "http/client"

url = "{{baseUrl}}/v1/webhooks?payorId="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/webhooks?payorId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/webhooks?payorId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/webhooks?payorId="

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

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

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

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

}
GET /baseUrl/v1/webhooks?payorId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/webhooks?payorId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/webhooks?payorId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/webhooks?payorId=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/webhooks?payorId=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/webhooks?payorId=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/webhooks',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/webhooks?payorId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/webhooks?payorId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/webhooks?payorId=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/webhooks?payorId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/webhooks',
  qs: {payorId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/webhooks');

req.query({
  payorId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/webhooks',
  params: {payorId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/webhooks?payorId=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/webhooks?payorId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/webhooks?payorId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/webhooks?payorId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/v1/webhooks?payorId=');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/webhooks');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'payorId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/webhooks');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'payorId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/webhooks?payorId=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/webhooks?payorId=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/webhooks?payorId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/webhooks"

querystring = {"payorId":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/webhooks"

queryString <- list(payorId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/webhooks?payorId=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/webhooks') do |req|
  req.params['payorId'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/webhooks";

    let querystring = [
        ("payorId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/webhooks?payorId='
http GET '{{baseUrl}}/v1/webhooks?payorId='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/webhooks?payorId='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/webhooks?payorId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "content": [
    {
      "authorizationHeader": "authorizationHeader",
      "categories": [
        null,
        null
      ],
      "enabled": true,
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "webhookUrl": "webhookUrl"
    },
    {
      "authorizationHeader": "authorizationHeader",
      "categories": [
        null,
        null
      ],
      "enabled": true,
      "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "payorId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "webhookUrl": "webhookUrl"
    }
  ],
  "links": [
    {
      "href": "href",
      "rel": "rel"
    },
    {
      "href": "href",
      "rel": "rel"
    }
  ],
  "page": {
    "numberOfElements": 0,
    "page": 5,
    "pageSize": 5,
    "totalElements": 6,
    "totalPages": 1
  }
}
POST Update Webhook
{{baseUrl}}/v1/webhooks/:webhookId
QUERY PARAMS

webhookId
BODY json

{
  "authorizationHeader": "",
  "categories": [],
  "enabled": false,
  "webhookUrl": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/webhooks/:webhookId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/webhooks/:webhookId" {:content-type :json
                                                                   :form-params {:authorizationHeader "authorizationHeader"
                                                                                 :categories [nil nil]
                                                                                 :enabled true
                                                                                 :webhookUrl "webhookUrl"}})
require "http/client"

url = "{{baseUrl}}/v1/webhooks/:webhookId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/webhooks/:webhookId"),
    Content = new StringContent("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/webhooks/:webhookId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/webhooks/:webhookId"

	payload := strings.NewReader("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}")

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

	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))

}
POST /baseUrl/v1/webhooks/:webhookId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/webhooks/:webhookId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/webhooks/:webhookId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/webhooks/:webhookId")
  .header("content-type", "application/json")
  .body("{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}")
  .asString();
const data = JSON.stringify({
  authorizationHeader: 'authorizationHeader',
  categories: [
    null,
    null
  ],
  enabled: true,
  webhookUrl: 'webhookUrl'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/webhooks/:webhookId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks/:webhookId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    webhookUrl: 'webhookUrl'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/webhooks/:webhookId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationHeader":"authorizationHeader","categories":[null,null],"enabled":true,"webhookUrl":"webhookUrl"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/webhooks/:webhookId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizationHeader": "authorizationHeader",\n  "categories": [\n    null,\n    null\n  ],\n  "enabled": true,\n  "webhookUrl": "webhookUrl"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/webhooks/:webhookId',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authorizationHeader: 'authorizationHeader',
  categories: [null, null],
  enabled: true,
  webhookUrl: 'webhookUrl'
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks/:webhookId',
  headers: {'content-type': 'application/json'},
  body: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    webhookUrl: 'webhookUrl'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/webhooks/:webhookId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authorizationHeader: 'authorizationHeader',
  categories: [
    null,
    null
  ],
  enabled: true,
  webhookUrl: 'webhookUrl'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/webhooks/:webhookId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationHeader: 'authorizationHeader',
    categories: [null, null],
    enabled: true,
    webhookUrl: 'webhookUrl'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/webhooks/:webhookId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationHeader":"authorizationHeader","categories":[null,null],"enabled":true,"webhookUrl":"webhookUrl"}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authorizationHeader": @"authorizationHeader",
                              @"categories": @[ ,  ],
                              @"enabled": @YES,
                              @"webhookUrl": @"webhookUrl" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/webhooks/:webhookId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/webhooks/:webhookId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/webhooks/:webhookId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authorizationHeader' => 'authorizationHeader',
    'categories' => [
        null,
        null
    ],
    'enabled' => null,
    'webhookUrl' => 'webhookUrl'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/webhooks/:webhookId', [
  'body' => '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/webhooks/:webhookId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizationHeader' => 'authorizationHeader',
  'categories' => [
    null,
    null
  ],
  'enabled' => null,
  'webhookUrl' => 'webhookUrl'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'authorizationHeader' => 'authorizationHeader',
  'categories' => [
    null,
    null
  ],
  'enabled' => null,
  'webhookUrl' => 'webhookUrl'
]));
$request->setRequestUrl('{{baseUrl}}/v1/webhooks/:webhookId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/webhooks/:webhookId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/webhooks/:webhookId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/webhooks/:webhookId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/webhooks/:webhookId"

payload = {
    "authorizationHeader": "authorizationHeader",
    "categories": [None, None],
    "enabled": True,
    "webhookUrl": "webhookUrl"
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/webhooks/:webhookId"

payload <- "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/webhooks/:webhookId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/webhooks/:webhookId') do |req|
  req.body = "{\n  \"authorizationHeader\": \"authorizationHeader\",\n  \"categories\": [\n    null,\n    null\n  ],\n  \"enabled\": true,\n  \"webhookUrl\": \"webhookUrl\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/webhooks/:webhookId";

    let payload = json!({
        "authorizationHeader": "authorizationHeader",
        "categories": (json!(null), json!(null)),
        "enabled": true,
        "webhookUrl": "webhookUrl"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/webhooks/:webhookId \
  --header 'content-type: application/json' \
  --data '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}'
echo '{
  "authorizationHeader": "authorizationHeader",
  "categories": [
    null,
    null
  ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
}' |  \
  http POST {{baseUrl}}/v1/webhooks/:webhookId \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizationHeader": "authorizationHeader",\n  "categories": [\n    null,\n    null\n  ],\n  "enabled": true,\n  "webhookUrl": "webhookUrl"\n}' \
  --output-document \
  - {{baseUrl}}/v1/webhooks/:webhookId
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizationHeader": "authorizationHeader",
  "categories": [, ],
  "enabled": true,
  "webhookUrl": "webhookUrl"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/webhooks/:webhookId")! 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()
POST pingWebhookV1
{{baseUrl}}/v1/webhooks/:webhookId/ping
QUERY PARAMS

webhookId
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/webhooks/:webhookId/ping");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/webhooks/:webhookId/ping")
require "http/client"

url = "{{baseUrl}}/v1/webhooks/:webhookId/ping"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/webhooks/:webhookId/ping"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/webhooks/:webhookId/ping");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/webhooks/:webhookId/ping"

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

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

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

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

}
POST /baseUrl/v1/webhooks/:webhookId/ping HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/webhooks/:webhookId/ping")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/webhooks/:webhookId/ping"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId/ping")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/webhooks/:webhookId/ping")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/webhooks/:webhookId/ping');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/webhooks/:webhookId/ping'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/webhooks/:webhookId/ping';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/webhooks/:webhookId/ping',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/webhooks/:webhookId/ping")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/webhooks/:webhookId/ping',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/webhooks/:webhookId/ping'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/webhooks/:webhookId/ping');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/v1/webhooks/:webhookId/ping'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/webhooks/:webhookId/ping';
const options = {method: 'POST'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/webhooks/:webhookId/ping"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/webhooks/:webhookId/ping" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/webhooks/:webhookId/ping",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/webhooks/:webhookId/ping');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/webhooks/:webhookId/ping');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/webhooks/:webhookId/ping');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/webhooks/:webhookId/ping' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/webhooks/:webhookId/ping' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/webhooks/:webhookId/ping")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/v1/webhooks/:webhookId/ping"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/webhooks/:webhookId/ping"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/webhooks/:webhookId/ping")

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

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/webhooks/:webhookId/ping') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/webhooks/:webhookId/ping";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}
curl --request POST \
  --url {{baseUrl}}/v1/webhooks/:webhookId/ping
http POST {{baseUrl}}/v1/webhooks/:webhookId/ping
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/webhooks/:webhookId/ping
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/webhooks/:webhookId/ping")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()
RESPONSE HEADERS

Content-Type
application/json
RESPONSE BODY json

{
  "id": "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "webhookId": "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}