https://api.trolley.com/v1/

'Authorization': 'prsign AVaAj764JE7C:
ce1f667c9cfee7a9291c61f68ff98144cc08c0291bbdcc3d0'

'X-PR-Timestamp': '1656393402'

curl 
-H "Authorization:prsign ALJVaAj4Z764JE7C:ce1f667913c9ca794cd89291c61f68ff98144291bbdcc3d0"
-H "X-PR-Timestamp:'1656393402'"
-L -X GET "https://api.trolley.com/v1/recipients/R-BawfevFF8oWx" \

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

{
  "ok": false,
  "errors": [
    {
      "code": "empty_field",
      "field": "type",
      "message": "Expected to have a non-null or non-empty value"
    },
    {
      "code": "empty_field",
      "field": "name",
      "message": "Expected to have a non-null or non-empty value"
    }
  ]
}

# Bash sample only includes example of sending a request.
# For sample code of generating Trolley Authorization header please 
# view samples of other supported programming languages

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X POST 'https://api.trolley.com/v1/recipients' \
--data-raw '{
  "type": "individual", 
  "firstName": "Elon", 
  "lastName": "Mask", 
  "email": "elon@mask.com"
  }' 

# Requires python-requests. Install with pip:
#
#   pip install requests
#

import json, hmac, hashlib, time, requests
from requests.auth import AuthBase

# Your key and secret as obtained by the Dashboard UI
ACCESS_KEY = '<YOUR_ACCESS_KEY>'
SECRET_KEY = '<YOUR_SECRET_KEY>'

# Create custom authentication for Trolley API
class TrolleyAuth(AuthBase):
    def __init__(self, access_key, secret_key):
        self.access_key = access_key
        self.secret_key = secret_key

    def __call__(self, request):
        print "PATH", request.path_url
        timestamp = str(int(time.time()))
        # if non-empty, body should be a valid JSON in string format
        message = '\n'.join([timestamp, request.method, request.path_url, (request.body or ''), ''])
        signature = hmac.new(self.secret_key, message, digestmod=hashlib.sha256).hexdigest()

        request.headers.update({
            'Authorization': 'prsign %s:%s' % (self.access_key, signature),
            'X-PR-Timestamp': timestamp,
        })

        print request.headers
        return request

api_url = 'https://api.trolley.com/v1/'
auth = TrolleyAuth(ACCESS_KEY, SECRET_KEY)

# Get list of recipients
r = requests.get(api_url + 'recipients', auth=auth)
print r.json()

function getTrolleyAuthHeader(params){
  const timestamp = Math.round(Date.now()/1000);
  const message = 
    `${timestamp}\n
     ${params.method}\n
     ${params.requestPath}\n
     ${params.body}\n`; // if non-empty, body should be a valid JSON in string format
  const signature = crypto.createHmac("sha256", params.SECRET_KEY).update(message).digest("hex");

  var trolleyHeaders = {
    Authorization: `prsign ${params.ACCESS_KEY}:${signature}`,
    "X-PR-Timestamp": timestamp,
    "Content-Type": "application/json",
  }
  
  return trolleyHeaders;
}

...

const ACCESS_KEY = '<YOUR_ACCESS_KEY>';
const SECRET_KEY = '<YOUR_SECRET_KEY>';

fetch("https://api.trolley.com/v1/recipients", {
    method: 'get',
    headers: getTrolleyAuthHeader({
      method: 'get'.toUpperCase(),
      requestPath: '/v1/recipients',
      body: '', // if non-empty, body should be a valid JSON in string format
      ACCESS_KEY: ACCESS_KEY,
      SECRET_KEY: SECRET_KEY
    }),
  })
    .then(result => console.log(result))
    .catch(error => console.log('error', error));

function getTrolleyAuthHeaders($params){
    $timestamp = time();
    $message = join("\n", [$timestamp, $params["method"], $params["requestPath"], $params["body"]]);
    $signature = hash_hmac("sha256", $message, $params["accessSecret"]);

    $authHeader[] = "Authorization: prsign " . $params["accessKey"] . ":" . $signature;
    $authHeader[] = "X-PR-Timestamp: " . $timestamp;
    $authHeader[] = "Content-Type: application/json";
    $authHeader[] = "Accept: application/json";

    return $authHeader;
}

...

$accessKey = "<YOUR_ACCESS_KEY>";
$accessSecret = "<YOUR_SECRET_KEY>";

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.trolley.com/v1/recipients",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLINFO_HEADER_OUT => true,
  CURLOPT_HTTPHEADER => getTrolleyAuthHeaders(
      array(
          "method" => strtoupper("GET"),
          "requestPath" => "/v1/recipients",
          "body" => "", // if non-empty, body should be a valid JSON in string format
          "accessKey" => $accessKey,
          "accessSecret" => $accessSecret
          )
      ),
));

$response = curl_exec($curl);
curl_close($curl);

print_r($response);

require 'digest'
require 'net/http'
require 'openssl'
require 'uri'
require 'json'

def get_trolley_auth_header (params)
  timestamp = Time.now.to_i
  message = [timestamp, params[:method], params[:requestPath], params[:body]].join("\n") + "\n"
  signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), params[:secret_key], message)

  {'X-PR-Timestamp': timestamp.to_s,
    'Authorization': 'prsign ' + params[:access_key] + ':' + signature,
    'Content-Type': 'application/json'}
end

ACCESS_KEY = '<YOUR_ACCESS_KEY>';
SECRET_KEY = '<YOUR_SECRET_KEY>';

headers = get_trolley_auth_header ({method: 'GET', 
    requestPath: '/v1/recipients',
    body: '', # if non-empty, body should be a valid JSON in string format
    access_key: ACCESS_KEY,
    secret_key: SECRET_KEY
  })

...

uri = URI.parse('https://api.trolley.com/v1/recipients')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri, headers)
response = http.request(request)
puts response.body["ok"]

//This sample uses .Net Core

using System.Net;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;

void setTrolleyAuthHeaders(string method, string requestPath, string body, string accessKey, string secretKey, ref HttpClient httpClient)
{
    TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
    TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
    int timeStamp = (int)unixTicks.TotalSeconds;

    string message = timeStamp + "\n" + method + "\n" + requestPath + "\n" + body + "\n";

    ASCIIEncoding encoding = new ASCIIEncoding();
    Byte[] messageBytes = encoding.GetBytes(message);
    Byte[] accessKeyBytes = encoding.GetBytes(secretKey);

    HMACSHA256 hash = new HMACSHA256(accessKeyBytes);
    Byte[] hashBytes = hash.ComputeHash(messageBytes);

    var signature = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
    var authHeader = "prsign " + accessKey + ":" + signature;

    httpClient.DefaultRequestHeaders.Add("Authorization", authHeader);
    httpClient.DefaultRequestHeaders.Add("X-PR-Timestamp", timeStamp.ToString());
    httpClient.DefaultRequestHeaders
      .Accept
      .Add(new MediaTypeWithQualityHeaderValue("application/json"));

}

...

string ACCESS_KEY = "<YOUR_ACCESS_KEY>";
string SECRET_KEY = "<YOUR_ACCESS_SECRET>";

var httpClient = new HttpClient(
    new HttpClientHandler {
        AutomaticDecompression = DecompressionMethods.GZip
        | DecompressionMethods.Deflate });

setTrolleyAuthHeaders( 
    "get".ToUpper(),
    "/v1/recipients",
    "",  // if non-empty, body should be a valid JSON in string format
    ACCESS_KEY,
    SECRET_KEY,
    ref httpClient);

httpClient.BaseAddress = new Uri("https://api.trolley.com");
HttpResponseMessage response = httpClient.GetAsync("/v1/recipients").Result;
response.EnsureSuccessStatusCode();
string result = response.Content.ReadAsStringAsync().Result;
Console.WriteLine("Result: " + result);

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

...

HashMap<String, String> getTrolleyAuthHeaders(HashMap<String, String> params) 
    throws UnsupportedEncodingException, 
            InvalidKeyException, 
            NoSuchAlgorithmException{

    HashMap<String,String> headerValues = new HashMap<String, String>();
    
    int timeStamp = (int) (System.currentTimeMillis() / 1000L);

    String message = timeStamp + "\n" 
    + params.get("method") + "\n" 
    + params.get("requestPath") + "\n" 
    + params.get("body") 
    + "\n";

    String digest = null;
    final SecretKeySpec key = new SecretKeySpec((params.get("secretKey")).getBytes("UTF-8"), "HmacSHA256");
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(key);

    byte[] bytes = mac.doFinal(message.getBytes("ASCII"));

    StringBuffer hash = new StringBuffer();
    for (int i = 0; i < bytes.length; i++) {
        String hex = Integer.toHexString(0xFF & bytes[i]);
        if (hex.length() == 1) {
            hash.append('0');
        }
        hash.append(hex);
    }
    digest = hash.toString();

    headerValues.put("Authorization", "prsign " + params.get("accessKey").toString() + ":" + digest);
    headerValues.put("X-PR-Timestamp", ""+timeStamp);
    headerValues.put("Content-Type", "application/json");

    return headerValues;
}

...

String ACCESS_KEY = "<YOUR_ACCESS_KEY>";
String SECRET_KEY = "<YOUR_SECRET_KEY>";

try {
    URL obj = new URL("https://api.trolley.com/v1/recipients");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");

    HashMap<String, String> headerValues = getTrolleyAuthHeaders(new HashMap<String,String>(){{
        put("method", "get".toUpperCase());
        put("requestPath", "/v1/recipients");
        put("body",""); // if non-empty, body should be a valid JSON in string format
        put("accessKey", ACCESS_KEY);
        put("secretKey", SECRET_KEY);
    }});

    //Setting header values
    for (String i : headerValues.keySet()) {
        con.setRequestProperty(i, headerValues.get(i));
    }

    BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();

    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();

    System.out.println(response.toString());

}catch (IOException e) {
    e.printStackTrace();
}

{
  "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
  "referenceId": "U341553728",
  "email": "richard@example.com",
  "name": "",
  "lastName": "Richard",
  "firstName": "Hendricks",
  "status": "active",
  "complianceStatus": "verified",
  "gravatarUrl": "https://www.gravatar.com/avatar/205e460b479e2e5b48aec07710c08d50",
  "language": "en",
  "dob": "1991-12-23",
  "passport": "HA24123423",
  "ssn": "123-45-6789",
  "governmentIds":[
    {
        "country": "US",
        "type": "SSN",
        "value": "********1234"
    },
    {
        "country": "US",
        "type": "passport",
        "value": "********1234"
    }
  ],
  "routeType": "eft",
  "routeMinimum": 1,
}

{
  "street1": "123 Main St",
  "street2": "",
  "city": "San Francisco",
  "region": "CA",
  "postalCode": "94131",
  "country": "US",
  "phone": "18005551212"
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X POST 'https://api.trolley.com/v1/recipients/' \
--data-raw '{
    "referenceId": "A-104",
    "type": "individual",
    "firstName": "Leonardo",
    "lastName": "da Vinci",
    "email": "leonardo@davinci.it",
    "dob": "1902-04-15",
    "address": {
        "street1": "191,  Royal Library of Turin",
        "street2": "P.za Castello",
        "city": "Torin TO",
        "postalCode": "10122",
        "country": "IT"
    },
    "governmentIds":[
        {
            "country":"IT",
            "type":"other",
            "value":"ABCD123123"
        }
    ]
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = {
    type: "individual",
    firstName: "John",
    lastName: "Smith",
    email: "jsmith@example.com",
    address: {
      city: "Montréal",
      country: "CA",
      phone: "+15141111111",
      postalCode: "A1A 1A1",
      region: "BC",
      street1: "Toad Street",
      street2: "Avenue Rock",
    },
  };

  const recipient = await client.recipient.create(body);
  console.log(recipient.id);
}

require 'paymentrails'

recipient = {
  type:"individual",
  firstName: 'John',
  lastName: 'Smith',
  email: 'jsmith@example.com',
  address: {
    city: "Montréal",
    country: "CA",
    phone: "+15141111111",
    postalCode: "A1A 1A1",
    region: "BC",
    street1: "Toad Street",
    street2: "Avenue Rock"
  }
  account: {
    type: 'paypal',
    emailAddress: 'jsmithpaypal@example.com'
  }
}

client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

client.recipient.create(recipient)

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient = PaymentRails\Recipient::create([
    'type' => "individual",
    'firstName' => 'Tom',
    'lastName' => 'Jones',
    'email' => 'jsmith@example.com',
    'address' => [
      "city" => "Montréal",
      "country" => "CA",
      "phone" => "+15141111111",
      "postalCode" => "A1A 1A1",
      "region" => "BC",
      "street1" => "Toad Street",
      "street2" => "Avenue Rock",
    ],
]);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Recipient recipient = new Recipient("individual", "TomJones@example.com", null, "Tom", "Jones");

            Recipient response = client.recipient.create(recipient);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient import Recipient
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"type": "individual", "firstName": "John", "lastName": "Smith", "email": "swd4356d@5gedmple.com"}
response = client.recipient.create(payload)

print(response.id)

{
  "ok": true,
  "recipient": {
    "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
    "referenceId": "jsmith11@example.com",
    "email": "jsmith11@example.com",
    "name": "John Smith",
    "lastName": "John",
    "firstName": "Smith",
    "type": "individual",
    "status": "incomplete",
    "language": "en",
    "complianceStatus": "verified",
    "dob": null,
    "updatedAt": "2017-03-20T19:06:40.937Z",
    "createdAt": "2017-03-17T20:10:45.818Z",
    "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
    "placeOfBirth": null,
    "ssn": null,
    "tags": [],
    "passport": "",
    "payoutMethod": "bank-transfer",
    "compliance": {
      "status": "verified",
      "checkedAt": "2017-03-20T19:06:23.916Z"
    },
    "routeType": "ach",
    "routeMinimum": "1",
    "estimatedFees": "1.25",
    "accounts": [],
    "address": {
      "street1": "",
      "street2": null,
      "city": "",
      "postalCode": "",
      "phone": "",
      "country": null,
      "region": null
    },
    "primaryCurrency": "CAD"
  }
}

{
  "ok": true,
  "recipient": {
    "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
    "referenceId": "jsmith11@example.com",
    "email": "jsmith11@example.com",
    "name": "John Smith",
    "lastName": "John",
    "firstName": "Smith",
    "type": "individual",
    "status": "incomplete",
    "language": "en",
    "complianceStatus": "verified",
    "dob": null,
    "updatedAt": "2017-03-20T19:06:40.937Z",
    "createdAt": "2017-03-17T20:10:45.818Z",
    "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
    "placeOfBirth": null,
    "ssn": null,
    "tags": [],
    "passport": "",
    "payoutMethod": "bank-transfer",
    "compliance": {
      "status": "verified",
      "checkedAt": "2017-03-20T19:06:23.916Z"
    },
    "routeType": "ach",
    "routeMinimum": "1",
    "estimatedFees": "1.25",
    "accounts": [],
    "address": {
      "street1": "Apt# 14",
      "street2": null,
      "city": "",
      "postalCode": "H3WXXX",
      "phone": "",
      "country": "CA",
      "region": "QC"
    },
    "primaryCurrency": "CAD"
  }
}

{
  "ok": false,
  "errors": [
    {
      "code": "invalid_field",
      "field": "email",
      "message": "Email is already exists"
    },
    {
      "code": "empty_field",
      "field": "name",
      "message": "Expected to have a non-null or non-empty value"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/R-1a2B3c4D5e6F7g8H9i0J1k' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.recipient.find("R-1a2B3c4D5e6F7g8H9i0J1k");
  console.log(recipient.id);
}

require 'paymentrails'

recipient_id = 3
client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

recipient = client.recipient.find(recipient_id)
puts recipient

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-1a2B3c4D5e6F7g8H9i0J1k';

$recipient = PaymentRails\Recipient::find($recipient_id);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            String recipient_id = "R-1a2B3c4D5e6F7g8H9i0J1k";
            Recipient response = client.recipient.find(recipient_id);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient import Recipient
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipient.find('R-12345')
print(response.id)

{
  "ok": true,
  "recipient": {
    "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
    "referenceId": "jsmith11@example.com",
    "email": "jsmith11@example.com",
    "name": "Richard Hendricks",
    "lastName": "Hendricks",
    "firstName": "Richard",
    "type": "individual",
    "status": "active",
    "language": "en",
    "complianceStatus": "verified",
    "dob": null,
    "updatedAt": "2017-03-20T19:06:40.937Z",
    "createdAt": "2017-03-17T20:10:45.818Z",
    "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
    "placeOfBirth": null,
    "ssn": null,
    "tags": [],
    "passport": "",
    "payoutMethod": "bank-transfer",
    "compliance": {
      "status": "verified",
      "checkedAt": "2017-03-20T19:06:23.916Z"
    },
    "routeType": "ach",
    "routeMinimum": "1", 
    "estimatedFees": "1.25",
    "accounts": [
      {
        "accountHolderName": "Richard Hendricks",
        "bankId": "123",
        "currency": "CAD",
        "country": "CA",
        "bankName": "TD CANADA TRUST",
        "branchId": "47261",
        "accountNum": "*****47"
      }
    ],
    "address": {
      "street1": "Apt# 14",
      "street2": null,
      "city": "",
      "postalCode": "H3WXXX",
      "phone": "",
      "country": "CA",
      "region": "QC"
    },
    "primaryCurrency": "CAD"
  }
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X PATCH 'https://api.trolley.com/v1/recipients/R-1a3B3c4D5e6F7g8H9i0J1k' \
--data-raw '{
    "firstName": "tom"
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = { firstName: "John" };

  const response = await client.recipient.update(
    "R-1a2B3c4D5e6F7g8H9i0J1k",
    body
  );
  console.log(response);
}

require 'paymentrails'

recipient_id = "R-1a2B3c4D5e6F7g8H9i0J1k"
recipient = { firstName: 'Mark'}

client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

client.recipient.update(recipient_id, recipient)

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Recipient::update($recipient_id, [
    "firstName" => "Mark",
]);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Recipient recipient = new Recipient("individual", "TomJones@example.com", null, "Tom", "Jones","R-1234565vcr4");
            bool res = client.recipient.update(recipient);
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient import Recipient
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {'firstName': 'tom'}
response = client.recipient.update('R-Wx2hvdwDY979ubBcjC4m5w', payload)
print(response)

{
  "ok": true,
  "recipient": {
    "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
    "referenceId": "jsmith11@example.com",
    "email": "jsmith11@example.com",
    "name": "tom Smith",
    "lastName": "Smith",
    "firstName": "tom",
    "type": "individual",
    "status": "incomplete",
    "language": "en",
    "complianceStatus": "verified",
    "dob": null,
    "updatedAt": "2017-03-20T19:06:40.937Z",
    "createdAt": "2017-03-17T20:10:45.818Z",
    "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
    "placeOfBirth": null,
    "ssn": null,
    "tags": [],
    "passport": "",
    "payoutMethod": "bank-transfer",
    "compliance": {
      "status": "verified",
      "checkedAt": "2017-03-20T19:06:23.916Z"
    },
    "routeType": "ach",
    "routeMinimum": "1", 
    "estimatedFees": "1.25",
    "accounts": [],
    "address": {
      "street1": "Apt# 14",
      "street2": null,
      "city": "",
      "postalCode": "H3WXXX",
      "phone": "",
      "country": "CA",
      "region": "QC"
    },
    "primaryCurrency": "CAD"
  }
}

{
  "ok": false,
  "errors": [
    {
      "code": "invalid_field",
      "field": "type",
      "message": "Expected to have a non-null or non-empty value"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X DELETE 'https://api.trolley.com/v1/recipients/R-1a3B3c4D5e6F7g8H9i0J1k'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.recipient.remove("R-1a2B3c4D5e6F7g8H9i0J1k");
  console.log(response);
}

require 'paymentrails'

recipient_id = "R-1a2B3c4D5e6F7g8H9i0J1k"
client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

client.recipient.delete(recipient_id)

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Recipient::delete($recipient_id);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY", "production");

            String recipient_id = "R-1a2B3c4D5e6F7g8H9i0J1k";
            String response = client.recipient.delete(recipient_id);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient import Recipient
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipient.delete('R-FR3r9U5TGff93tQTncAZ66')

print(response)

{
  "ok": true,
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X DELETE 'https://api.trolley.com/v1/recipients' \
--data-raw '{
  "ids": [
    "R-1a2B3c4D5e6F7g8H9i0J1k", 
    "R-1a2B3c4D5e6F7g8H9i0J1k"
    ]
}'

{
  "ok": true,
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.recipient.search(1, 10, "term");
  console.log(response);
}

require 'paymentrails'

client  = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")
results = client.recipient.search()

puts results

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-1a2B3c4D5e6F7g8H9i0J1k';

$recipients = PaymentRails\Recipient::all();
foreach ($recipients as $recipient) {
    print_r($recipient);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
           var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY", "production");

            List<Recipient> recipients = client.recipient.search("John", 1, 10);

            foreach(Recipient recipient in recipients)
            {
                Console.WriteLine(recipient);
            }
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient import Recipient
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipient.search()
print(recipient.id)

{
  "ok": true,
  "recipients": [
    {
      "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
      "referenceId": "rhendricks@example.com",
      "email": "rhendricks@example.com",
      "name": "Richard Hendricks",
      "lastName": "Hendricks",
      "firstName": "Richard",
      "type": "individual",
      "status": "active",
      "language": "en",
      "complianceStatus": "verified",
      "dob": null,
      "updatedAt": "2017-03-20T19:06:40.937Z",
      "createdAt": "2017-03-17T20:10:45.818Z",
      "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
      "placeOfBirth": null,
      "ssn": null,
      "tags": [],
      "passport": "",
      "payoutMethod": "bank-transfer",
      "compliance": {
        "status": "verified",
        "checkedAt": "2017-03-20T19:06:23.916Z"
      },
      "routeType": "ach",
      "routeMinimum": "1", 
      "estimatedFees": "1.25",
      "accounts": [
        {
          "accountHolderName": "Richard Hendricks",
          "bankId": "123",
          "currency": "CAD",
          "country": "CA",
          "bankName": "TD CANADA TRUST",
          "branchId": "47261",
          "accountNum": "*****47"
        }
      ],
      "address": {
        "street1": "Apt# 14",
        "street2": null,
        "city": "",
        "postalCode": "H3WXXX",
        "phone": "",
        "country": "CA",
        "region": "QC"
      },
      "primaryCurrency": "CAD"
    },
    {
      "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
      "referenceId": "jsmith11@example.com",
      "email": "jsmith11@example.com",
      "name": "John Smith",
      "lastName": "John",
      "firstName": "Smith",
      "type": "individual",
      "status": "active",
      "language": "en",
      "complianceStatus": "verified",
      "dob": null,
      "updatedAt": "2017-03-20T19:06:40.937Z",
      "createdAt": "2017-03-17T20:10:45.818Z",
      "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
      "placeOfBirth": null,
      "ssn": null,
      "tags": [],
      "passport": "",
      "payoutMethod": "bank-transfer",
      "compliance": {
        "status": "verified",
        "checkedAt": "2017-03-20T19:06:23.916Z"
      },
      "routeType": "ach",
      "routeMinimum": "1", 
      "estimatedFees": "1.25",
      "accounts": [
        {
          "accountHolderName": "John Smith",
          "bankId": "123",
          "currency": "CAD",
          "country": "CA",
          "bankName": "TD CANADA TRUST",
          "branchId": "47261",
          "accountNum": "*****47"
        }
      ],
      "address": {
        "street1": "Apt# 14",
        "street2": null,
        "city": "",
        "postalCode": "H3WXXX",
        "phone": "",
        "country": "CA",
        "region": "QC"
      },
      "primaryCurrency": "CAD"
    }
  ],
  "meta": {
    "page": 1,
    "pages": 1,
    "records": 2
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/R-4QoXiSPjbnLuUmQR2bgb8C/logs' \

{
  "ok": true,
  "activities": [
    {
      "ip": "::ffff:10.0.2.2",
      "url": "/v1/recipients/R-91XNW81D85DMG/log",
      "method": "GET",
      "headers": {
        "host": "api.local.dev:3000",
        "connection": "keep-alive",
        "postman-token": "47cad157-855e-49fe-45d6-d61a02ffa802",
        "cache-control": "no-cache",
        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
        "x-api-key": "pk_live_*********************************",
        "content-type": "application/json",
        "accept": "*/*",
        "accept-encoding": "gzip, deflate, sdch",
        "accept-language": "en-US,en;q=0.8"
      },
      "request": "",
      "response": "{\"ok\":false,\"errors\":[{\"code\":\"not_found\",\"message\":\"Object not found\"}]}",
      "code": 404,
      "source": "api",
      "testMode": false,
      "createdAt": "2017-03-22T17:57:32.786Z"
    }
  ],
  "meta": {
    "page": 1,
    "pages": 1,
    "records": 2
  }
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/R-4QoXiSPjbnLuUmQR2bgb8C/payments' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.payment.search({
    recipientId: "R-1a2B3c4D5e6F7g8H9i0J1k",
  });
  console.log(response);
}

from paymentrails.configuration import Configuration
from paymentrails.payment import Payment
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipient.find('R-QSCaFZrdWHXyW7raHUmerd','payments')
print(response.id)

{
  "ok": true,
  "payments": [
    {
      "id": "P-1a2B3c4D5e6F7g8H9i0J1k",
      "recipient": {
        "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
        "referenceId": "jsmith11@example.com",
        "email": "jsmith11@example.com",
        "name": "Richard Hendricks",
        "lastName": "Hendricks",
        "firstName": "Richard",
        "type": "individual",
        "status": "active",
        "language": "en",
        "complianceStatus": "verified",
        "dob": null,
        "updatedAt": "2017-03-20T19:06:40.937Z",
        "createdAt": "2017-03-17T20:10:45.818Z",
        "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
        "placeOfBirth": null,
        "ssn": null,
        "tags": [],
        "passport": "",
        "payoutMethod": "bank-transfer",
        "compliance": {
          "status": "verified",
          "checkedAt": "2017-03-20T19:06:23.916Z"
        },
        "accounts": [
          {
            "accountHolderName": "Richard Hendricks",
            "bankId": "123",
            "currency": "CAD",
            "country": "CA",
            "bankName": "TD CANADA TRUST",
            "branchId": "47261",
            "accountNum": "*****47"
          }
        ],
        "address": {
          "street1": "Apt# 14",
          "street2": null,
          "city": "",
          "postalCode": "H3WXXX",
          "phone": "",
          "country": "CA",
          "region": "QC"
        },
        "primaryCurrency": "CAD"
      },
      "status": "pending",
      "sourceAmount": "100.10",
      "exchangeRate": "1.0000",
      "fees": "1.25",
      "recipientFees": "1.25",
      "targetAmount": "98.85",
      "fxRate": "2.000000",
      "memo": "memo",
      "processedAt": null,
      "createdAt": "2017-03-21T20:56:43.714Z",
      "updatedAt": "2017-03-21T21:10:05.874Z",
      "merchantFees": "0.00",
      "compliance": {
        "status": "pending",
        "checkedAt": null
      },
      "sourceCurrency": "CAD",
      "sourceCurrencyName": "Canadian Dollar",
      "targetCurrency": "CAD",
      "targetCurrencyName": "Canadian Dollar",
      "batch": {
        "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
        "createdAt": "2017-03-21T20:56:43.690Z",
        "updatedAt": "2017-03-21T21:10:05.890Z",
        "sentAt": null,
        "completedAt": null
      }
    },
    {
      "id": "P-1a2B3c4D5e6F7g8H9i0J1k",
      "recipient": {
        "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
        "referenceId": "jsmith11@example.com",
        "email": "jsmith11@example.com",
        "name": "Richard Hendricks",
        "lastName": "Hendricks",
        "firstName": "Richard",
        "type": "individual",
        "status": "active",
        "language": "en",
        "complianceStatus": "verified",
        "dob": null,
        "updatedAt": "2017-03-20T19:06:40.937Z",
        "createdAt": "2017-03-17T20:10:45.818Z",
        "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
        "placeOfBirth": null,
        "ssn": null,
        "tags": [],
        "passport": "",
        "payoutMethod": "bank-transfer",
        "compliance": {
          "status": "verified",
          "checkedAt": "2017-03-20T19:06:23.916Z"
        },
        "accounts": [
          {
            "accountHolderName": "Richard Hendricks",
            "bankId": "123",
            "currency": "CAD",
            "country": "CA",
            "bankName": "TD CANADA TRUST",
            "branchId": "47261",
            "accountNum": "*****47"
          }
        ],
        "address": {
          "street1": "Apt# 14",
          "street2": null,
          "city": "",
          "postalCode": "H3WXXX",
          "phone": "",
          "country": "CA",
          "region": "QC"
        },
        "primaryCurrency": "CAD"
      },
      "status": "pending",
      "sourceAmount": "100.10",
      "exchangeRate": "1.0000",
      "fees": "1.25",
      "recipientFees": "1.25",
      "targetAmount": "0.00",
      "fxRate": "2.000000",
      "memo": "memo",
      "processedAt": null,
      "createdAt": "2017-03-20T15:11:18.517Z",
      "updatedAt": "2017-03-20T15:11:18.517Z",
      "merchantFees": "0.00",
      "compliance": {
        "status": "pending",
        "checkedAt": null
      },
      "sourceCurrency": "CAD",
      "sourceCurrencyName": "Canadian Dollar",
      "targetCurrency": "CAD",
      "targetCurrencyName": "Canadian Dollar",
      "batch": {
        "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
        "createdAt": "2017-03-20T15:11:18.486Z",
        "updatedAt": "2017-03-20T15:11:18.582Z",
        "sentAt": null,
        "completedAt": null
      }
    }
  ],
  "meta": {
    "page": 1,
    "pages": 1,
    "records": 2
  }
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/R-4QoXiSPjbnLuUmQR2bgb8C/offlinePayments' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.offlinePayment.search({
    recipientId: "R-1a2B3c4D5e6F7g8H9i0J1k",
  });
  console.log(response);
}

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$offlinePayments = PaymentRails\OfflinePayments::search(["recipientId" => "R-1a2B3c4D5e6F7g8H9i0J1k"]);
foreach ($offlinePayments as $offlinePayment) {
  print_r($offlinePayment);
}

require 'paymentrails'

client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

offline_payments = client.offline_payment.search("R-1a2B3c4D5e6F7g8H9i0J1k")

{
  "ok": true,
  "offlinePayments": [
    {
      "amount": "100.00",
      "category": "services",
      "createdAt": "2019-10-31T20:24:29.954Z",
      "currency": "USD",
      "deletedAt": null,
      "equivalentWithholdingAmount": "24.00",
      "equivalentWithholdingCurrency": "USD",
      "externalId": "id-123",
      "id": "OP-3xghXMEcedrjPEo3KedqsR",
      "memo": "A memo",
      "processedAt": "2019-08-15T20:23:59.000Z",
      "recipientId": "R-4321c356vrcerc54js",
      "tags": [],
      "taxReportable": true,
      "updatedAt": "2019-10-31T20:24:29.954Z",
      "withholdingAmount": "24.00",
      "withholdingCurrency": "USD"
    },
    {
      "amount": "100.00",
      "category": "services",
      "createdAt": "2019-10-31T20:24:29.954Z",
      "currency": "USD",
      "deletedAt": null,
      "equivalentWithholdingAmount": "24.00",
      "equivalentWithholdingCurrency": "USD",
      "externalId": "id-123",
      "id": "OP-4xghXMEcedrjPEo3KedqsR",
      "memo": "A memo",
      "processedAt": "2019-08-15T20:23:59.000Z",
      "recipientId": "R-4321c356vrcerc54js",
      "tags": [],
      "taxReportable": true,
      "updatedAt": "2019-10-31T20:24:29.954Z",
      "withholdingAmount": "24.00",
      "withholdingCurrency": "USD"
    }
  ]
}

{
  "ok": false,
  "errors": [
    {
      "code": "not_found",
      "message": "Object not found"
    }
  ]
}

{
  "name": "Jon Smith",
  "street1": "123 Main St",
  "street2": "",
  "city": "San Francisco",
  "region": "CA",
  "postal": "94131",
  "country": "US"
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X POST 'https://api.trolley.com/v1/recipients/R-4625iLug2GKqKZG2WzAf3e/accounts/' \
--data-raw '{
    "type": "bank-transfer",
    "primary": true, 
    "country": "CA", 
    "currency": "CAD",
    "accountNum": "604622847", 
    "bankId": "123", 
    "branchId": "47261",
    "accountHolderName": "John Smith"
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = {
    type: "bank-transfer",
    primary: "true",
    country: "CA",
    currency: "CAD",
    accountNum: "012345678",
    bankId: "004",
    branchId: "47261",
    accountHolderName: "John Smith",
  };
  const response = await client.recipientAccount.create(
    "R-4625iLug2GKqKZG2WzAf3e",
    body
  );
  console.log(response);
}

require 'paymentrails'

account = {
  "type": "bank-transfer",
  "primary": "true",
  "country": "CA",
  "currency": "CAD",
  "accountNum": "012345678",
  "bankId": "004",
  "branchId": "47261",
  "accountHolderName": "John Smith"
}

client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

client.recipient_account.create('R-4625iLug2GKqKZG2WzAf3e', account)

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-PuzPJLVYQXBbPSMQKwmJ5G';

$response = PaymentRails\RecipientAccount::create($recipient_id, [
    "type" => "bank-transfer",
    "primary" => "true",
    "country" => "CA",
    "currency" => "CAD",
    "accountNum" => "012345678",
    "bankId" => "004",
    "branchId" => "47261",
    "accountHolderName" => "John Smith"
]);


// Example of code for `paypal` type account
$response = PaymentRails\RecipientAccount::create($recipient_id, [
    "type" => "paypal",
    "emailAddress": "jsmithpaypal@example.com",
]);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            RecipientAccount recipientAccount = new RecipientAccount("bank-transfer", "EUR", null, null, "FR", "FR14 **** **** **** **** **** ***", "123456");
            RecipientAccount recipientAccount = client.recipientAccount.create(recipient.id, recipientAccount);

            Console.WriteLine(recipientAccount);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient_account import RecipientAccount
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"type": "bank-transfer", "primary": "true", "country": "CA", "currency": "CAD","accountNum": "604622847", "bankId": "123", "branchId": "47261",  "accountHolderName": "John Smith"}
response = client.recipientAccount.create('R-4625iLug2GKqKZG2WzAf3e', payload)

print(response.id)

{
  "ok": true
  "account": {
       "recipientAccountId": "A-UnukXDTbLtxtDLXVZGE9re",
       "primary": true,
       "currency": "CAD",
       "country": "CA",
       "type": "bank-transfer",
       "accountNum": "*****2847",
       "accountHolderName": "John Smith",
       "bankId": "123",
       "branchId": "47261",
       "bankName": "TD bank"
   }
}


// response for `paypal` account
{
  "ok": true,
  "account": {
    "type": "paypal",
    "emailAddress": "jsmithpaypal@example.com",
    "recipientAccountId": "A-7ccjKkGNyQRXRnEAfqTd7d",
    "primary": true,
    "currency": "CAD"
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X DELETE 'https://api.trolley.com/v1/recipients/R-PuzPJLVYQXBbPSMQKwmJ5G/accounts/A-KKHb8MpFvju6vDMBLPmtej' \

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-PuzPJLVYQXBbPSMQKwmJ5G';
$account_id = 'A-KKHb8MpFvju6vDMBLPmtej';

$response = PaymentRails\RecipientAccount::delete($recipient_id, $account_id);

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.recipientAccount.remove(
    "R-4625iLug2GKqKZG2WzAf3e",
    "A-1a2b3c4f5g6h7j8k9l0m"
  );
  console.log(response);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            var response = client.recipientAccount.delete("R-1234", "A-1234");

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient_account import RecipientAccount
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipientAccount.delete('R-4625iLug2GKqKZG2WzAf3e','A-14WyPhgH2XPEy2Kha47MDk')

print(response)

{
  "ok": true,
  "object": "deleted"
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/recipients/R-PuzPJLVYQXBbPSMQKwmJ5G/accounts/A-KKHb8MpFvju6vDMBLPmtej' \

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-PuzPJLVYQXBbPSMQKwmJ5G';
$account_id = 'A-KKHb8MpFvju6vDMBLPmtej';

$response = PaymentRails\RecipientAccount::find($recipient_id, $account_id);

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.recipientAccount.find(
    "R-4625iLug2GKqKZG2WzAf3e",
    "A-a1b2c3d4e5f5g6h7i8j9k0"
  );
  console.log(response);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            RecipientAccount recipientAccount = client.recipientAccount.find(recipient.id, recipientAccount);

            Console.WriteLine(recipientAccount);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.recipient_account import RecipientAccount
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.recipientAccount.find('R-4625iLug2GKqKZG2WzAf3e','A-2DQMpN4jurTFn9gRxobx4C')

print(response.id)

{
  "ok": true,
  "account": {
    "type": "paypal",
    "emailAddress": "rain123@gmail.com",
    "recipientAccountId": "A-7ccjKkGNyQRXRnEAfqTd7d",
    "primary": false,
    "currency": "CAD"
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X PATCH 'https://api.trolley.com/v1/recipients/R-PuzPJLVYQXBbPSMQKwmJ5G/accounts/A-KKHb8MpFvju6vDMBLPmtej' \
--data-raw '{
    "primary": true
}'

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$recipient_id = 'R-PuzPJLVYQXBbPSMQKwmJ5G';
$account_id = 'A-KKHb8MpFvju6vDMBLPmtej';

$response = PaymentRails\RecipientAccount::update($recipient_id, $account_id, [
    "primary" => false,
]);

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = { primary: "false" };
  const response = await client.recipientAccount.update(
    "R-4625iLug2GKqKZG2WzAf3e",
    "A-a1b2c3d4e5f5g6h7i8j9k0",
    body
  );
  console.log(response);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            RecipientAccount recipientAccount = new RecipientAccount("bank-transfer", "EUR", "A-UnukXDTbLtxtDLXVZGE9re", null, "FR", "FR14 1234 1234 1234 1234 1234 123", "123456");
            RecipientAccount recipientAccount = client.recipientAccount.update(recipient.id, recipientAccount);

            Console.WriteLine(recipientAccount);
            Console.Read();
        }
    }

{
  "ok": true,
  "object": "updated"
}

from paymentrails.configuration import Configuration
from paymentrails.recipient_account import RecipientAccount
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"accountHolderName": "Acer Phillips"}
response = client.RecipientAccount.update('R-4625iLug2GKqKZG2WzAf3e','A-2DQMpN4jurTFn9gRxobx4C', payload)

print(response)

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X POST 'https://api.trolley.com/v1/batches' \
--data-raw '{
    "currency": "USD",
    "description": "Month end payout",
    "payments": [
        {
            "recipient": {
                "id": "R-1a2B3c4D5e6F7g8H9i0J1k"
            },
            "amount": "150",
            "currency": "USD"
        }
    ]
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = {
    payments: [
      {
        recipient: {
          id: "R-1a2B3c4D5e6F7g8H9i0J1k",
        },
        amount: "65",
        currency: "CAD",
      },
    ],
  };
  const response = await client.batch.create(body);
  console.log(response.batch.id);
}

require 'paymentrails'

# "id" replaceable with referenceId or email
batch = {
  description: "Batch Description",
  currency: "USD",
  payments: [
    { recipient: { id: "R-RECIPIENT_ID" }, amount: "100", currency: "USD" },
    { recipient: { id: "R-RECIPIENT_ID" }, amount: "200", currency: "USD", }
  ]
}

client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

client.batch.create(batch)

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$response = PaymentRails\Batch::create([
      'description' => "Batch Description",
      'currency' => 'USD',
      'payments' => [
          0 => [
              "recipient" => [
                  "id" => "R-RECIPIENT_ID",
              ],
              "amount" => "100",
              "currency" => "USD"
          ],
          1 => [
              "recipient" => [
                  "email" => "RECIPIENT_EMAIL",
              ],
              "amount" => "200",
              "currency" => "USD"
          ],
      ],
]);

echo $response;

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Batch batch = new Batch("Integration Test Create", null, "USD", 0);

            Batch response = client.batch.create(batch);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.batch import Batch
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"payments": [{"recipient": {"id": "R-1a2B3c4D5e6F7g8H9i0J1k"}, "amount": "65", "memo": "", "currency": "USD"}]}
response = client.batch.create(payload)
print(response.id)

{
  "ok": true,
  "batch": {
    "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
    "status": "open",
    "tags": [],
    "amount": "8.75",
    "totalPayments": 2,
    "currency": "CAD",
    "description": "Weekly Payouts on 2017-2-27",
    "sentAt": null,
    "completedAt": null,
    "createdAt": "2017-03-27T20:19:47.378Z",
    "updatedAt": "2017-03-27T20:19:47.518Z",
    "quoteExpiredAt": "2017-03-28T04:08:52.634Z"
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/batches/B-1a2B3c4D5e6F7g8H9i0J1k/' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.batch.find("B-1a2b3c4d5e6f7g8h9i0jk1");
  console.log(response.batch.id);
}

require 'paymentrails'

batch_id = "B-1a2B3c4D5e6F7g8H9i0J1k"
client = PaymentRails.client("YOUR-PUBLIC-KEY", "YOUR-PRIVATE-KEY")

batch = client.batches.find(batch_id)

puts batch

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$batch_id = 'B-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Batch::find($batch_id);
echo $response

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Batch response = client.batch.find("B-1a2B3c4D5e6F7g8H9i0J1ks");

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.batch import Batch
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.batch.find('B-7ySLLBn57BhebTEMSiAkDH')
print(recipient.id)

{
  "ok": true,
  "batch": {
    "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
    "status": "open",
    "tags": [],
    "amount": "98.75",
    "totalPayments": 2,
    "currency": "CAD",
    "description": "Weekly Payouts on 2017-2-23",
    "sentAt": null,
    "completedAt": null,
    "createdAt": "2017-03-23T15:21:51.171Z",
    "updatedAt": "2017-03-23T15:21:51.254Z",
    "quoteExpiredAt": "2017-03-29T04:08:52.634Z",
    "payments": {
      "payments": [
        {
          "id": "P-1a2B3c4D5e6F7g8H9i0J1k",
          "recipient": {
            "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
            "referenceId": "jsmith11@example.com",
            "email": "jsmith11@example.com",
            "name": "John Smith",
            "status": "active",
            "country": "Canada"
          },
          "method": "bank",
          "methodDisplay": "Bank Transfer",
          "status": "pending",
          "sourceAmount": "0.00",
          "targetAmount": "100.00",
          "isSupplyPayment": true,
          "memo": "memo",
          "fees": "1.25",
          "recipientFees": "0.00",
          "exchangeRate": "1.0000",
          "processedAt": null,
          "merchantFees": "1.25",
          "sourceCurrency": "CAD",
          "sourceCurrencyName": "Canadian Dollar",
          "targetCurrency": "CAD",
          "targetCurrencyName": "Canadian Dollar",
          "compliance": {
            "status": "pending",
            "checkedAt": null
          }
        },
        {
          "id": "P-1a2B3c4D5e6F7g8H9i0J1k",
          "recipient": {
            "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
            "referenceId": "jsmith11@example.com",
            "email": "jsmith11@example.com",
            "name": "Richard Hendricks",
            "status": "active",
            "country": "Canada"
          },
          "method": "bank",
          "methodDisplay": "Bank Transfer",
          "status": "pending",
          "sourceAmount": "100.00",
          "targetAmount": "0.00",
          "isSupplyPayment": false,
          "memo": "memo",
          "fees": "1.25",
          "recipientFees": "1.25",
          "exchangeRate": "1.0000",
          "processedAt": null,
          "merchantFees": "0.00",
          "sourceCurrency": "CAD",
          "sourceCurrencyName": "Canadian Dollar",
          "targetCurrency": "CAD",
          "targetCurrencyName": "Canadian Dollar",
          "compliance": {
            "status": "pending",
            "checkedAt": null
          }
        }
      ],
      "meta": {
        "page": 1,
        "pages": 1,
        "records": 2
      }
    }
  }
}

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.batch.remove("B-1a2b3c4d5e6f7g8h9i0jk1");
  console.log(response);
}

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$batch_id = 'B-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Batch::delete($batch_id);

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            String response = client.batch.delete("B-1a2B3c4D5e6F7g8H9i0J1k");

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.batch import Batch
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.batch.delete('B-UPQsFgaADFetkXtwJPnjGF')
print(response)

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X DELETE 'https://api.trolley.com/v1/batches/B-1a2b3c4d5e6f7g8h9i0jk1/' \

{
  "ok": true
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X DELETE 'https://api.trolley.com/v1/batches/' \
--data-raw '{
    "ids": [
      "B-1a2b3c4d5e6f7g8h9i0jk1",
      "B-3c4d5e6f7g8h9i0jk11a2b"
    ]
}'

{
  "ok": true
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/batches?page=1&pageSize=10' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.batch.search(1, 10, "John");
  console.log(response);
}

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$batches = PaymentRails\Batch::all($batch_id, $payment_id);
foreach ($batches as $batch) {
  print_r($batch);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            List<Batch> batches = client.batch.search("John",1,10);

            foreach(Batch batch in batches){
                Console.WriteLine(batches);
            }
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.batch import Batch
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.batch.search()
print(batch.id)

{
  "ok": true,
  "batches": [
    {
      "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
      "status": "accepted",
      "tags": [],
      "amount": "109.75",
      "totalPayments": 1,
      "currency": "CAD",
      "description": "Weekly Payouts on 2017-0-11",
      "sentAt": null,
      "completedAt": null,
      "createdAt": "2017-01-11T23:30:52.974Z",
      "updatedAt": "2017-01-11T23:31:38.954Z",
      "quoteExpiredAt": "2017-01-12T04:08:52.634Z"
    },
    {
      "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
      "status": "complete",
      "tags": [],
      "amount": "109.75",
      "totalPayments": 1,
      "currency": "CAD",
      "description": "Weekly Payouts on 2017-0-11",
      "sentAt": "2017-01-11T23:18:48.091Z",
      "completedAt": "2017-01-11T23:18:49.222Z",
      "createdAt": "2017-01-11T23:18:37.976Z",
      "updatedAt": "2017-01-11T23:18:49.222Z",
      "quoteExpiredAt": "2017-01-12T04:08:52.634Z"
    }
  ]
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X POST 'https://api.trolley.com/v1/batches/B-1a2B3c4D5e6F7g8H9i0J1k/payments/' \
--data-raw '{
    "recipient" : {
        "id":"R-1a2B3c4D5e6F7g8H9i0J1k"
    },
    "amount": "150",
    "currency": "USD"
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = {
    recipient: {
      id: "R-1a2B3c4D5e6F7g8H9i0J1k",
    },
    sourceAmount: "100.10",
    sourceCurrency: "CAD",
    memo: "Freelance payment",
  };
  var batchId = "B-1a2B3c4D5e6F7g8H9i0J1k";
  const response = await client.payment.create(batchId, body);
  console.log(response.batch.id);
}

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$batch_id = 'B-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Batch::createPayment($batch_id, [
    'recipient' => [ 'id' => 'R-1a2B3c4D5e6F7g8H9i0J1k' ],
    'sourceAmount' => "100.10",
    'memo' => 'Freelance payment'
]);
echo $response;

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Recipient recipient = new Recipient("individual", "TomJones@example.com", null, "Tom", "Jones", "R-1234c356vrcerc54js")

            Payment payment = new Payment(recipient, 10.00, "EUR", 0, null, null);
            payment.batchId = "B-1a2B3c4D5e6F7g8H9i0J1k";
            Payment response = client.payment.create(payment);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.payment import Payment
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"recipient":{"id": "R-12345"},"sourceAmount":"100.10","memo":"Freelance payment"}
batchId = "B-1a2B3c4D5e6F7g8H9i0J1k"
response = client.payment.create(payload, batchId)
print(response.id)

{
  "ok": true,
  "payment": {
    "id": "	P-1a2B3c4D5e6F7g8H9i0J1k",
    "recipient": {
      "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
      "referenceId": "jsmith11@example.com",
      "email": "jsmith11@example.com",
      "name": "John Smith",
      "lastName": "John",
      "firstName": "Smith",
      "type": "individual",
      "status": "active",
      "language": "en",
      "complianceStatus": "verified",
      "dob": null,
      "updatedAt": "2017-03-20T19:06:40.937Z",
      "createdAt": "2017-03-17T20:10:45.818Z",
      "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
      "placeOfBirth": null,
      "ssn": null,
      "tags": [],
      "passport": "",
      "payoutMethod": "bank-transfer",
      "compliance": {
        "status": "verified",
        "checkedAt": "2017-03-20T19:06:23.916Z"
      },
      "accounts": [
        {
          "accountHolderName": "John Smith",
          "bankId": "123",
          "currency": "CAD",
          "country": "CA",
          "bankName": "TD CANADA TRUST",
          "branchId": "47261",
          "accountNum": "*****47"
        }
      ],
      "address": {
        "street1": "Apt# 14",
        "street2": null,
        "city": "",
        "postalCode": "H3WXXX",
        "phone": "",
        "country": "CA",
        "region": "QC"
      },
      "primaryCurrency": "CAD"
    },
    "status": "pending",
    "sourceAmount": "100.10",
    "exchangeRate": "1.0000",
    "fees": "1.25",
    "recipientFees": "1.25",
    "targetAmount": "0.00",
    "fxRate": "2.000000",
    "memo": "momo",
    "processedAt": null,
    "createdAt": "2017-03-27T20:51:39.567Z",
    "updatedAt": "2017-03-27T20:51:39.567Z",
    "merchantFees": "0.00",
    "compliance": {
      "status": "pending",
      "checkedAt": null
    },
    "batch": {
      "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
      "createdAt": "2017-03-21T20:56:43.690Z",
      "updatedAt": "2017-03-28T04:09:02.966Z",
      "sentAt": "2017-03-28T04:08:52.634Z",
      "completedAt": "2017-03-28T04:08:54.353Z"
    },
    "sourceCurrency": "CAD",
    "sourceCurrencyName": "Canadian Dollar",
    "targetCurrency": "CAD",
    "targetCurrencyName": "Canadian Dollar",
    "category": "services",
    "coverFees": false,
    "currency": "CAD",
    "equivalentWithholdingAmount": "0.00",
    "equivalentWithholdingCurrency": "CAD",
    "estimatedDeliveryAt": null,
    "externalId": "",
    "failureMessage": null,
    "initiatedAt": null,
    "isSupplyPayment": false,
    "merchantId": "M-Osg3dh2b0m1cRg9b8Shd2d",
    "methodDisplay": "Bank Transfer",
    "returnedAmount": "0.00",
    "returnedAt": null,
    "returnedNote": null,
    "returnedReason": [],
    "settledAt": null,
    "tags": [],
    "taxBasisAmount": "0.00",
    "taxBasisCurrency": "CAD",
    "taxReportable": true,
    "withholdingAmount": "0.00",
    "withholdingCurrency": "CAD"
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X GET 'https://api.trolley.com/v1/batches/B-1a2B3c4D5e6F7g8H9i0J1k/payments/P-1a2B3c4D5e6F7g8H9i0J1k' \

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  const response = await client.payment.find("P-1a2B3c4D5e6F7g8H9i0J1k");
  console.log(response.payment.id);
}

<?php
use PaymentRails;

PaymentRails\Configuration::publicKey('YOUR_PUBLIC_KEY');
PaymentRails\Configuration::privateKey('YOUR_PRIVATE_KEY');

$batch_id = 'B-1a2B3c4D5e6F7g8H9i0J1k';
$payment_id = 'P-1a2B3c4D5e6F7g8H9i0J1k';

$response = PaymentRails\Batch::findPayment($batch_id, $payment_id);
echo $response;

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Payment response = client.payment.find("P-1a2B3c4D5e6F7g8H9i0J1k");

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.payment import Payment
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

response = client.payment.find('P-UPQsFgaADFetkXtwJPnjGF')
print(response)

{
  "ok": true,
  "payment": {
    "id": "P-1a2B3c4D5e6F7g8H9i0J1k",
    "recipient": {
      "id": "R-1a2B3c4D5e6F7g8H9i0J1k",
      "referenceId": "jsmith11@example.com",
      "email": "jsmith11@example.com",
      "name": "Richard Hendricks",
      "lastName": "Hendricks",
      "firstName": "Richard",
      "type": "individual",
      "status": "active",
      "language": "en",
      "complianceStatus": "verified",
      "dob": null,
      "updatedAt": "2017-03-20T19:06:40.937Z",
      "createdAt": "2017-03-17T20:10:45.818Z",
      "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
      "placeOfBirth": null,
      "ssn": null,
      "tags": [],
      "passport": "",
      "payoutMethod": "bank-transfer",
      "compliance": {
        "status": "verified",
        "checkedAt": "2017-03-20T19:06:23.916Z"
      },
      "routeType": "ach",
      "routeMinimum": "1", 
      "estimatedFees": "1.25",
      "accounts": [
        {
          "accountHolderName": "Richard Hendricks",
          "bankId": "123",
          "currency": "CAD",
          "country": "CA",
          "bankName": "TD CANADA TRUST",
          "branchId": "47261",
          "accountNum": "*****47"
        }
      ],
      "address": {
        "street1": "Apt# 14",
        "street2": null,
        "city": "",
        "postalCode": "H3WXXX",
        "phone": "",
        "country": "CA",
        "region": "QC"
      },
      "primaryCurrency": "CAD"
    },
    "status": "processed",
    "sourceAmount": "100.10",
    "exchangeRate": "1.0000",
    "fees": "1.25",
    "recipientFees": "1.25",
    "targetAmount": "98.85",
    "fxRate": "2.000000",
    "memo": "memo",
    "processedAt": "2017-03-28T04:09:02.955Z",
    "createdAt": "2017-03-21T20:56:43.714Z",
    "updatedAt": "2017-03-28T04:09:02.955Z",
    "merchantFees": "0.00",
    "compliance": {
      "status": "verified",
      "checkedAt": "2017-03-28T04:08:53.297Z"
    },
    "sourceCurrency": "CAD",
    "sourceCurrencyName": "Canadian Dollar",
    "targetCurrency": "CAD",
    "targetCurrencyName": "Canadian Dollar",
    "batch": {
      "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
      "createdAt": "2017-03-21T20:56:43.690Z",
      "updatedAt": "2017-03-28T04:09:02.966Z",
      "sentAt": "2017-03-28T04:08:52.634Z",
      "completedAt": "2017-03-28T04:08:54.353Z"
    },
    "category": "services",
    "coverFees": false,
    "currency": "CAD",
    "equivalentWithholdingAmount": "0.00",
    "equivalentWithholdingCurrency": "CAD",
    "estimatedDeliveryAt": null,
    "externalId": "",
    "failureMessage": null,
    "initiatedAt": null,
    "isSupplyPayment": false,
    "merchantId": "M-Osg3dh2b0m1cRg9b8Shd2d",
    "methodDisplay": "Bank Transfer",
    "returnedAmount": "0.00",
    "returnedAt": null,
    "returnedNote": null,
    "returnedReason": [],
    "settledAt": null,
    "tags": [],
    "taxBasisAmount": "0.00",
    "taxBasisCurrency": "CAD",
    "taxReportable": true,
    "withholdingAmount": "0.00",
    "withholdingCurrency": "CAD"
  }
}

curl \
-H 'Authorization: prsign <ACCESS-KEY>:<SIGNATURE>' \
-H 'Content-Type: application/json' \
-H 'X-PR-Timestamp: <timestamp>' \
-X PATCH 'https://api.trolley.com/v1/batches/B-1a2B3c4D5e6F7g8H9i0J1k/payments/P-1a2B3c4D5e6F7g8H9i0J1k' \
--data-raw '{
    "amount": "100",
    "currency": "USD",
    "memo": "correcting payment amount"
}'

const paymentrails = require("paymentrails");

const client = paymentrails.connect({
  key: "YOUR-API-KEY",
  secret: "YOUR-API-SECRET",
  environment: "production",
});

async function main() {
  var body = { sourceAmount: "900.90" };
  const response = await client.payment.update(
    'P-1a2B3c4D5e6F7g8H9i0J1k","B-1a2B3c4D5e6F7g8H9i0J1k',
    body
  );
  console.log(response);
}

using PaymentRails.Types;
using PaymentRails;

class Program
    {
        static void Main(string[] args)
        {
            var client = new PaymentRails.Gateway("YOUR-API-KEY", "YOUR-SECRET-KEY");

            Recipient recipient = new Recipient("individual", "test.create" + uuid + "@example.com", null, "Tom", "Jones");
            Payment payment = new Payment(recipient, 10.00, "EUR", 0, null, null);
            payment.batchId = "B-12345";
            string response = client.payment.update(payment);

            Console.WriteLine(response);
            Console.Read();
        }
    }

from paymentrails.configuration import Configuration
from paymentrails.payment import Payment
from paymentrails.gateway import Gateway

client = Configuration.gateway("YOUR-PUBLIC-API","YOUR-PRIVATE-API","production")

payload = {"sourceAmount":"100.10"}
response = client.payment.create(payload)
print(response.id)

{
  "ok": true,
  "payment": {
    "id": "	P-1a2B3c4D5e6F7g8H9i0J1k",
    "recipient": {
      "id": "R-1a3B3c4D5e6F7g8H9i0J1k",
      "referenceId": "jsmith11@example.com",
      "email": "jsmith11@example.com",
      "name": "John Smith",
      "lastName": "John",
      "firstName": "Smith",
      "type": "individual",
      "status": "active",
      "language": "en",
      "complianceStatus": "verified",
      "dob": null,
      "updatedAt": "2017-03-20T19:06:40.937Z",
      "createdAt": "2017-03-17T20:10:45.818Z",
      "gravatarUrl": "https://s3.amazonaws.com/static.api.trolley.com/icon_user.svg",
      "placeOfBirth": null,
      "ssn": null,
      "tags": [],
      "passport": "",
      "payoutMethod": "bank-transfer",
      "compliance": {
        "status": "verified",
        "checkedAt": "2017-03-20T19:06:23.916Z"
      },
      "accounts": [
        {
          "accountHolderName": "John Smith",
          "bankId": "123",
          "currency": "CAD",
          "country": "CA",
          "bankName": "TD CANADA TRUST",
          "branchId": "47261",
          "accountNum": "*****47"
        }
      ],
      "address": {
        "street1": "Apt# 14",
        "street2": null,
        "city": "",
        "postalCode": "H3WXXX",
        "phone": "",
        "country": "CA",
        "region": "QC"
      },
      "primaryCurrency": "CAD"
    },
    "status": "pending",
    "sourceAmount": "100.10",
    "exchangeRate": "1.0000",
    "fees": "1.25",
    "recipientFees": "1.25",
    "targetAmount": "0.00",
    "fxRate": "2.000000",
    "memo": "momo",
    "processedAt": null,
    "createdAt": "2017-03-27T20:51:39.567Z",
    "updatedAt": "2017-03-27T20:51:39.567Z",
    "merchantFees": "0.00",
    "compliance": {
      "status": "pending",
      "checkedAt": null
    },
    "batch": {
      "id": "B-1a2B3c4D5e6F7g8H9i0J1k",
      "createdAt": "2017-03-21T20:56:43.690Z",
      "updatedAt": "2017-03-28T04:09:02.966Z",
      "sentAt": "2017-03-28T04:08:52.634Z",
      "completedAt": "2017-03-28T04:08:54.353Z"
    },
    "sourceCurrency": "CAD",
    "sourceCurrencyName": "Canadian Dollar",
    "targetCurrency": "CAD",
    "targetCurrencyName": "Canadian Dollar",
    "category": "services",
    "coverFees": false,
    "currency": "CAD",
    "equivalentWithholdingAmount": "0.00",
    "equivalentWithholdingCurrency": "CAD",
    "estimatedDeliveryAt": null,
    "externalId": "",
    "failureMessage": null,
    "initiatedAt": null,
    "isSupplyPayment": false,
    "merchantId": "M-Osg3dh2b0m1cRg9b8Shd2d",
    "methodDisplay": "Bank Transfer",
    "returnedAmount": "0.00",
    "returnedAt": null,
    "returnedNote": null,
    "returnedReason": [],
    "settledAt": null,
    "tags": [],
    "taxBasisAmount": "0.00",
    "taxBasisCurrency": "CAD",
    "taxReportable": true,
    "withholdingAmount": "0.00",
    "withholdingCurrency": "CAD"
  }
}