Boarding on the ProPay website

The simplest solution can often be the best. ProPay’s website can handle all the boarding that you need or want to do. If you are willing to let us host the signup experience, then all you need to do is collect a ProPay account number from the merchants you intend to process for. Account numbers are made plainly obvious to ProPay merchants, who can just type them into your system.

The signup experience can be co-branded for your specific merchants.
In the very near future, ProPay will also offer full-branding of the signup page along with the rest of the ProPay website.

You can use the API to prevent users from "fat fingering" their account numbers.
The ProPay API includes a method that will allow you to "Ping" a ProPay account number to get details about it. When a user types in his or her number, make this call, and display a confirmation popup before storing the details of the account. Take a look at the technical details required to perform this operation:
How to call this method?

Example Request

Example Response

Implementation Details
Request Submission

Response Handling

Request Submission

Response Handling

Request Submission

Response Handling

Request Submission

Response Handling

Request Values
Response Values
How to call this method?

You should submit a post of XML data to the following URL
 
HTTP URL(s)
Example Request

Example Response

<!-- Sample request including all mandatory and some optional tags -->
<?xml version='1.0'?>
<!DOCTYPE Request.dtd>
<XMLRequest>
<certStr>MyTestCertStr00000001</certStr>
<class>partner</class>
<XMLTrans>
<transType>13</transType>
<sourceEmail>jsmith@aol.com</sourceEmail>
</XMLTrans>
</XMLRequest>

<!-- Sample API Response -->
<?xml version="1.0" standalone="no"?>
<XMLResponse xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance xsi:noNamespaceSchemaLocation="http://www.propay.com/schema/PPResponse.xsd>
<XMLTrans>
<transType>13</transType>
<sourceEmail>smaxfield@propay.com</sourceEmail>
<accountNum>548670</accountNum>
<tier>Corporate</tier>
<expiration>11/28/2012 3:36:00 AM</expiration>
<signupDate>6/1/2005 4:47:00 PM</signupDate>
<affiliation>EXPRESS1</affiliation>
<accntStatus>Ready</accntStatus>
<addr>5971 S Clear Vista Drive</addr>
<city>Kearns</city>
<state>UT</state>
<zip>84118</zip>
<apiReady>Y</apiReady>
<status>00</status>
</XMLTrans>
</XMLResponse>

Implementation Details
Request Submission

namespace MSAPI_Ping
{
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;

/*
ProPay provides the following code “AS IS.”
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/
public class AccountPingTransType13
{
public static void PingAccount()
{
var pingRequest = new XmlTransactionRequest { CertificationString = "8d393deefe974b808aa05c0f7c8bc0", TerminalID = "11f0842492", };
var xmlTransaction = new XmlPingTransaction
{
TransType = "13",
AccountNumber = "32542254",
ExternalId = "",
SourceEmail = "7180bae6-266a-41e6-aa69-24cb2d245af0@qamail.com",
};
pingRequest.Transactions.Add(xmlTransaction);
string request = XmlSerializer<XmlTransactionRequest>.WriteToString(pingRequest);
SubmitRequest(request);
}

private static void SubmitRequest(string request)
{
byte[] dataToSend = Encoding.UTF8.GetBytes(request);

// Change the following URL to point to production instead of integration
WebRequest webRequest = WebRequest.Create("https://xmltest.propay.com/API/PropayAPI.aspx");
webRequest.Method = "POST";
webRequest.ContentLength = dataToSend.Length;
webRequest.ContentType = "text/xml";
Stream dataStream = webRequest.GetRequestStream();
dataStream.Write(dataToSend, 0, dataToSend.Length);
dataStream.Close();

string response = string.Empty;

try
{
WebResponse apiResponse = webRequest.GetResponse();


using (StreamReader sr = new StreamReader(apiResponse.GetResponseStream()))
{
response += sr.ReadToEnd();
}
}
catch (WebException wex)
{
HttpWebResponse httpResponse = wex.Response as HttpWebResponse;
using (Stream responseStream = httpResponse.GetResponseStream())
using (StreamReader reader = new StreamReader(responseStream))
{
response = reader.ReadToEnd();
}
}

// Call Parse Function for the XML response
ParseResponse(response);
}

private static void ParseResponse(string response)
{
var load = XDocument.Parse(response);
var transType = Convert.ToInt32(load.Descendants().First(p => p.Name.LocalName == "transType").Value);
var accountId = Convert.ToInt32(load.Descendants().First(p => p.Name.LocalName == "accountNum").Value);
var status = load.Descendants().First(p => p.Name.LocalName == "status").Value;
var accntStatus = load.Descendants().First(p => p.Name.LocalName == "accntStatus").Value;
var address = load.Descendants().First(p => p.Name.LocalName == "addr").Value;
var affiliation = load.Descendants().First(p => p.Name.LocalName == "affiliation").Value;
var apiReady = load.Descendants().First(p => p.Name.LocalName == "apiReady").Value;
var city = load.Descendants().First(p => p.Name.LocalName == "city").Value;
var currencyCode = load.Descendants().First(p => p.Name.LocalName == "currencyCode").Value;
var expiration = load.Descendants().First(p => p.Name.LocalName == "expiration").Value;
var signupDate = load.Descendants().First(p => p.Name.LocalName == "signupDate").Value;
var sourceEmail = load.Descendants().First(p => p.Name.LocalName == "sourceEmail").Value;
var state = load.Descendants().First(p => p.Name.LocalName == "state").Value;
var tier = load.Descendants().First(p => p.Name.LocalName == "tier").Value;
var zip = load.Descendants().First(p => p.Name.LocalName == "zip").Value;
var creditCardTransactionLimit = load.Descendants().First(p => p.Name.LocalName == "CreditCardTransactionLimit").Value;
var creditCardMonthlyLimit = load.Descendants().First(p => p.Name.LocalName == "CreditCardMonthLimit").Value;
var achPaymentPerTranLimit = load.Descendants().First(p => p.Name.LocalName == "ACHPaymentPerTranLimit").Value;
var achPaymentMonthlyLimit = load.Descendants().First(p => p.Name.LocalName == "ACHPaymentMonthLimit").Value;
var creditCardMonthlyVolume = load.Descendants().First(p => p.Name.LocalName == "CreditCardMonthlyVolume").Value;
var achPaymentMonthlyVolume = load.Descendants().First(p => p.Name.LocalName == "ACHPaymentMonthlyVolume").Value;
var reserveBalance = load.Descendants().First(p => p.Name.LocalName == "ReserveBalance").Value;
}
}

public static class XmlSerializer<T>
{
public static XmlSerializer Serializer = new XmlSerializer(typeof(T));

/// <summary>
/// Writes to a string <paramref name="data"/> using <see cref="Encoding.UTF8"/>.
/// </summary>
/// <remarks>
/// This defaults the encoding to <see cref="Encoding.UTF8"/> because that is what xml internal uses
/// to read in xml transactions.
/// </remarks>
/// <param name="data">The data to write to a string.</param>
/// <returns>A string representation of <paramref name="data"/>.</returns>
public static string WriteToString(T data)
{
return WriteToString(data, Encoding.UTF8);
}

/// <summary>
/// Writes to a string <paramref name="data"/> using <paramref name="encoding"/>.
/// </summary>
/// <param name="data">The data to write to a string.</param>
/// <param name="encoding">The encoding to use when writing to a string.</param>
/// <returns>A string representation of <paramref name="data"/>.</returns>
public static string WriteToString(T data, Encoding encoding)
{
string retVal;
using (MemoryStream memoryStream = new MemoryStream())
{
using (XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, encoding))
{
Serializer.Serialize(xmlTextWriter, data);
}

retVal = encoding.GetString(memoryStream.ToArray());
}

return retVal;
}
}


[XmlInclude(typeof(XmlPingTransaction))]
public class XmlTransaction
{
/// <summary>
/// The transaction type.
/// </summary>
[XmlElement("transType")]
public string TransType = string.Empty;
}

/// <summary>
/// The XML request object.
/// </summary>
[XmlRoot("XMLRequest")]
public class XmlTransactionRequest
{
/// <summary>
/// Supplied by ProPay, Used to access the API.
/// </summary>
[XmlElement("certStr")]
public string CertificationString = string.Empty;

/// <summary>
/// Omit unless specifically instructed by ProPay, Used to access the API.
/// </summary>
[XmlElement("termid")]
public string TerminalID = string.Empty;

/// <summary>
/// The XML transactions to process.
/// </summary>
[XmlElement("XMLTrans")]
public List<XmlTransaction> Transactions = new List<XmlTransaction>();
}


public class XmlPingTransaction : XmlTransaction
{
/// <summary>
/// This is a client’s own unique identifier. Typically used as the distributor ID.
/// </summary>
[XmlElement("externalId")]
public string ExternalId = string.Empty;

/// <summary>
/// Merchant/Individual email address. Must be unique in ProPay system.
/// </summary>
[XmlElement("sourceEmail")]
public string SourceEmail = string.Empty;

/// <summary>
/// The account number assigned by ProPay.
/// </summary>
[XmlElement("accountNum")]
public string AccountNumber = string.Empty;

}
}

Response Handling

Request Submission

/**
 * ProPay provides the following code “AS IS.” ProPay makes no warranties and
 * ProPay disclaims all warranties and conditions, express, implied or
 * statutory, including without limitation the implied warranties of title,
 * non-infringement, merchantability, and fitness for a particular purpose.
 * ProPay does not warrant that the code will be uninterrupted or error free,
 * nor does ProPay make any warranty as to the performance or any results that
 * may be obtained by use of the code.
 */
 
<?php
class ProPayApi
{
/* change this to the production url for going live after testing https://api.propay.com */
private $_apiBaseUrl = 'https://xmltestapi.propay.com';

/* for xml */
/** @var \SimpleXMLElement */
private $_xmlRequestObject;
/** @var \SimpleXMLElement */
private $_xmlResponseObject;
/** @var string */
private $_xmlUrl;

/**
* sets the xml request object
* @param string $xmlData - containing XML
* @return $this
*/
public function setXMLRequestData($xmlData) {
$this->_xmlRequestObject = simplexml_load_string($xmlData);
return $this;
}

/**
* @param string $xmlData - containing XML
* @return $this
*/
public function setXMLResponseData($xmlData) {
$this->_xmlResponseObject = simplexml_load_string($xmlData);
return $this;
}

/**
* @return mixed
*/
public function getXMLRequestObject() {
return $this->_xmlRequestObject;
}

/**
* @return mixed
*/
public function getXMLResponseObject() {
return $this->_xmlResponseObject;
}

/**
* @param \SimpleXMLElement $xmlObject
* @return $this
*/
public function setXMLRequestObject(\SimpleXMLElement $xmlObject) {
$this->_xmlRequestObject = $xmlObject;
return $this;
}

/**
* @param \SimpleXMLElement $xmlObject
* @return $this
*/
public function setXMLResponseObject(\SimpleXMLElement $xmlObject) {
$this->_xmlResponseObject = $xmlObject;
return $this;
}

/**
* sets the url for the XML request
* @param string $xmlUrl
* @return $this
*/
public function setXMLUrl($xmlUrl) {
$this->_xmlUrl = $xmlUrl;
return $this;
}

/**
* posts XML to the server
* @return $this
*/
public function postXML() {
$header = [
"Content-type:text/xml; charset=\"utf-8\"",
"Accept: text/xml"
];


$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => $this->_xmlUrl,
CURLOPT_TIMEOUT => 30,
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => $this->_xmlRequestObject->asXML(),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => $header,
CURLOPT_SSL_VERIFYPEER => 0,
CURLOPT_SSL_VERIFYHOST => 0,
CURLOPT_HTTPAUTH => CURLAUTH_ANY
]);
$result = curl_exec($curl);
$this->_xmlResponseObject = simplexml_load_string($result);
curl_close($curl);
return $this;
}
}

$proPayAPI = new ProPayApi();
$data = "<?xml version='1.0'?>
<!DOCTYPE Request.dtd>
<XMLRequest>
</XMLRequest>";
$simpleXML = new \SimpleXMLElement($data);
$simpleXML->addChild('certStr','cert string here');
$simpleXML->addChild('termId','terminal id');
$simpleXML->addChild('class','partner');
$simpleXML->addChild('XMLTrans');
$simpleXML->XMLTrans->addChild('transType', 13);
$simpleXML->XMLTrans->addChild('accountNum', 32291150);
$simpleXML->XMLTrans->addChild('externalId', 3212157);
$simpleXML->XMLTrans->addChild('sourceEmail', 'someemail@somedomain.com');

// returns XML
$result =
$proPayAPI->setXMLUrl('https://xmltest.propay.com/API/PropayAPI.aspx')
->setXMLRequestData($simpleXML->asXML())
->postXML()
->getXMLResponseObject()->asXML();

// if you prefer a simpleXML object you just retrieve the object back to work with that
$result = $proPayAPI->getXMLResponseObject();

Response Handling

Request Submission


/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import java.io.IOException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator.Feature;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.ObjectMapper;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
import com.mashape.unirest.request.HttpRequest;
import com.mashape.unirest.request.HttpRequestWithBody;

public class AccountPingTransactionXmlSample {

 final static String ApiUrl = "https://xmltest.propay.com/API/PropayAPI.aspx";

 public static void main(String[] args) {
configureObjectMapper();

AccountPingTransactionXmlSample program = new AccountPingTransactionXmlSample();

TransactionRequest transactionRequest = program.getRequest();
AccountPingTransactionRequest transaction = program.getAccountPingTransactionRequest();

transactionRequest.getTransactions().add(transaction);

AccountPingResponse response = program.sendRequest(transactionRequest);

System.out.println("Response:");
AccountPingTransactionResponse transactionResponse = response.getTransactions().get(0);

System.out.println("Transaction type: " + transactionResponse.TransType);
System.out.println("Status: " + transactionResponse.Status);
System.out.println("Account Number: " + transactionResponse.AccountNumber);
System.out.println("Affiliation: " + transactionResponse.AffiliationName);
System.out.println("Tier: " + transactionResponse.TierName);
System.out.println("Signup date: " + transactionResponse.SignupDate);
System.out.println("Expiration date: " + transactionResponse.ExpirationDate);
System.out.println("Account status: " + transactionResponse.AccountStatus);
System.out.println("Street address: " + transactionResponse.StreetAddress);
System.out.println("City: " + transactionResponse.City);
System.out.println("State: " + transactionResponse.State);
System.out.println("Zip: " + transactionResponse.Zip);
System.out.println("API Ready? " + transactionResponse.ApiReady);
System.out.println("Currency code: " + transactionResponse.CurrencyCode);
System.out.println("Credit card per transaction limit:" + transactionResponse.CreditCardTransactionLimit);
System.out.println("Credit card monthly limit: " + transactionResponse.CreditCardMonthLimit);
System.out.println("Credit card monthly volume: " + transactionResponse.CreditCardMonthlyVolume);
System.out.println("ACH per transaction limit: " + transactionResponse.ACHPaymentPerTranLimit);
System.out.println("ACH monthly limit: " + transactionResponse.ACHPaymentMonthLimit);
System.out.println("ACH monthly volume: " + transactionResponse.ACHPaymentMonthlyVolume);
System.out.println("Reserve balance: " + transactionResponse.ReserveBalance);
 }

 /**
* Get the affiliate credential id. This would normally be in a
* configuration file or database.
*/
 private String getCertString() {
return "TiAuNrNwEjRnScCaE9RcTcS7ReI9NG";
 }

 /**
* Get the request container, setting up the authentication.
*
* @return The request container.
*/
 private TransactionRequest getRequest() {
String certString = getCertString();

TransactionRequest transactionRequest = new TransactionRequest();
transactionRequest.CertificationString = certString;
transactionRequest.TerminalId = "ReI9NG";

return transactionRequest;
 }

 /**
* Get the transaction details, how much to refund, on which transaction.
*
*/
 private AccountPingTransactionRequest getAccountPingTransactionRequest() {
AccountPingTransactionRequest transaction = new AccountPingTransactionRequest();

transaction.AccountNumber = "30829192";

return transaction;
 }

 /**
* Send the refund transaction request.
*
* @param transactionRequest
* The transaction request.
* @return The transaction response.
*/
 private AccountPingResponse sendRequest(TransactionRequest transactionRequest) {
HttpRequestWithBody request = this.createRequest(ApiUrl);

request.body(transactionRequest);

AccountPingResponse response = this.executeRequest(request, AccountPingResponse.class);

return response;
 }

 /**
* Create the request instance. This ensures that the correct content type
* and accept headers are attached to each request.
*
* @param resourceUrl
* The URL of the resource.
* @return The request instance.
*/
 public HttpRequestWithBody createRequest(String resourceUrl) {

HttpRequestWithBody request = Unirest.post(resourceUrl).header("accept", "text/xml").header("Content-Type",
"text/xml");

return request;
 }

 /**
* Execute a request.
*
* @param request
* The request to perform.
* @param responseClass
* The type instance of the return type.
* @return An instance of type T or null if there was an error.
*/
 public <T> T executeRequest(HttpRequest request, Class<T> responseClass) {
try {
HttpResponse<T> response = request.asObject(responseClass);
if (response.getStatus() != 200) { // HTTP OK response code
System.out.println(response.getStatusText());
return null;
}

return response.getBody();
} catch (UnirestException e) {
e.printStackTrace();
}

return null;
 }

 /**
* Configures the mapping between XML and Classes.
*
* This is boilerplate Unirest & Jackson configuration. It should only need
* to be done once in a full solution.
*/
 private static void configureObjectMapper() {
Unirest.setObjectMapper(new ObjectMapper() {

private com.fasterxml.jackson.databind.ObjectMapper jacksonObjectMapper = new XmlMapper()
.configure(Feature.WRITE_XML_DECLARATION, true);

public <T> T readValue(String value, Class<T> valueType) {
try {
return jacksonObjectMapper.readValue(value, valueType);
} catch (IOException e) {
throw new RuntimeException(e);
}
}

public String writeValue(Object value) {
try {
return jacksonObjectMapper.writeValueAsString(value);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
});
 }
}


// -------------------------------------------------------------------------------------------- //
// Object files

// Transaction.java

/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

@JacksonXmlRootElement(localName = "XMLTrans")
public class Transaction {
 @JacksonXmlProperty(localName = "transType")
 public String TransType;
}


// -------------------------------------------------------------------------------------------- //
// TransactionRequest.java

/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

@JacksonXmlRootElement(localName = "XMLRequest")
public class TransactionRequest {
 @JacksonXmlProperty(localName = "certStr")
 public String CertificationString;

 @JacksonXmlProperty(localName = "class")
 public final String ClassType = "partner";
 /**
* Omit unless specifically instructed by ProPay, Used to access the API
*/
 @JacksonXmlProperty(localName = "termid")
 public String TerminalId;

 @JacksonXmlProperty(localName = "XMLTrans")
 @JacksonXmlElementWrapper(useWrapping = false)
 private List<Transaction> Transactions;

 public TransactionRequest() {
this.Transactions = new ArrayList<Transaction>();
 }

 /**
* @return the transactions
*/
 @JacksonXmlProperty(localName = "XMLTrans")
 @JacksonXmlElementWrapper(useWrapping = false)
 public List<Transaction> getTransactions() {
return this.Transactions;
 }
}

// -------------------------------------------------------------------------------------------- //
// AccountPingTransactionRequest.java

/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;

public class AccountPingTransactionRequest extends Transaction {
 /**
* The account number for the account to lookup.
*
* One of accountNumber, sourceEmail or externalId is required.
*/
 @JacksonXmlProperty(localName = "accountNum")
 public String AccountNumber;

 /**
* The merchant's email address.
*
* One of accountNumber, sourceEmail or externalId is required.
*/
 @JacksonXmlProperty(localName = "sourceEmail")
 public String SourceEmail;

 /**
* A client specific unique identifier.
*
* One of accountNumber, sourceEmail or externalId is required.
*/
 @JacksonXmlProperty(localName = "externalId")
 public String ExternalId;

 public AccountPingTransactionRequest() {
this.TransType = "13";
 }
}


// -------------------------------------------------------------------------------------------- //
// AccountPingTransactionResponse.java

/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;

public class AccountPingTransactionResponse extends Transaction {

 @JacksonXmlProperty(localName = "status")
 public String Status;

 @JacksonXmlProperty(localName = "accountNum")
 public String AccountNumber;

 @JacksonXmlProperty(localName = "tier")
 public String TierName;

 @JacksonXmlProperty(localName = "expiration")
 public String ExpirationDate;

 @JacksonXmlProperty(localName = "signupDate")
 public String SignupDate;

 @JacksonXmlProperty(localName = "affiliation")
 public String AffiliationName;

 @JacksonXmlProperty(localName = "accntStatus")
 public String AccountStatus;

 @JacksonXmlProperty(localName = "addr")
 public String StreetAddress;

 @JacksonXmlProperty(localName = "city")
 public String City;

 @JacksonXmlProperty(localName = "state")
 public String State;

 @JacksonXmlProperty(localName = "zip")
 public String Zip;

 @JacksonXmlProperty(localName = "apiReady")
 public String ApiReady;

 @JacksonXmlProperty(localName = "currencyCode")
 public String CurrencyCode;

 public String CreditCardTransactionLimit;

 public String CreditCardMonthLimit;

 public String ACHPaymentPerTranLimit;

 public String ACHPaymentMonthLimit;

 public String CreditCardMonthlyVolume;

 public String ACHPaymentMonthlyVolume;

 public String ReserveBalance;
}

// -------------------------------------------------------------------------------------------- //
// AccountPingResponse.java

/*
ProPay provides the following code "AS IS."
ProPay makes no warranties and ProPay disclaims all warranties and conditions, express, implied or statutory,
including without limitation the implied warranties of title, non-infringement, merchantability, and fitness for a particular purpose.
ProPay does not warrant that the code will be uninterrupted or error free,
nor does ProPay make any warranty as to the performance or any results that may be obtained by use of the code.
*/

import java.util.List;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

@JacksonXmlRootElement(localName = "XMLResponse")
public class AccountPingResponse {
 @JacksonXmlProperty(localName = "XMLTrans")
 @JacksonXmlElementWrapper(useWrapping = false)
 private List<AccountPingTransactionResponse> transactions;

 /**
* @return the transactions
*/
 public List<AccountPingTransactionResponse> getTransactions() {
return transactions;
 }
}

Response Handling

The following sample uses the Unirest and Jackson libraries.

You can add them to your project using:

Apache Maven
<dependency>
<groupId>com.mashape.unirest</groupId>
<artifactId>unirest-java</artifactId>
<version>1.4.9</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.8.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.0.pr3</version>
</dependency>

Gradle/Grails
compile 'com.mashape.unirest:unirest-java:1.4.9'
compile 'com.fasterxml.jackson.core:jackson-databind:2.8.8.1'
compile 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.9.0.pr3'

Request Submission

Response Handling

Request Values

Element

Type

Max

Required

Notes

accountNum

Int(32)

 

** Required

Assigned to each account by ProPay

externalId

String

20

** Required

This is a client’s own unique identifier. Typically used as the distributor ID.

sourceEmail

String

 

** Required

Merchant/Individual email address. Must be unique in ProPay system.

Response Values

Element

Type

Notes

status

string

Result of the transaction request. See ProPay Appendix for result code definitions

accntStatus

string

The ProPay account Status.

*See ProPay Appendix for a description of each account status type.

accountNum

string

Assigned to each account by ProPay

Addr

string

Merchant/Individual physical Address.

Affiliation

string

The Affiliation the account belongs to

apiReady

string

Indicates if the ProPay account may process against the Application Programing Interface. Y indicates yes, N indicates no.

City

string

Account physical Address.

CurrencyCode

string

The ProPay account processing currency.

Expiration

string

The ProPay account expiration date

signupDate

string

The ProPay account creation dated

sourceEmail

string

Merchant/Individual email address. Must be unique in ProPay system.

State

string

Merchant/Individual physical Address.

Tier

string

Type of ProPay account provided to user.

visaCheckoutMerchantId

string

The boarded Visa Checkout Merchant Id. Only returns if applicable.

Zip

string

Merchant/Individual physical Address.

CreditCardTransactionLimit

string

Maximum amount for a credit card transaction.

CreditCardMonthLimit

string

Maximum amount for credit card transactions during a month.

ACHPaymentPerTranLimit

string

ACH payment limit per transaction for the associated account.

ACHPaymentMonthLimit

string

ACH payment transaction monthly limit for the associated account.

CreditCardMonthlyVolume

string

Monthly volume for credit cards payments.

ACHPaymentMonthlyVolume

string

Monthly volume for ACH payments for the account.

ReserveBalance

string

Reserve balance for the account.

MasterPassCheckoutMerchantId

string

The boarded MasterPass Checkout Merchant Id.

How to call this method?

Example Request

Example Response

Implementation Details
Request Submission

Response Handling

Request Submission

Response Handling

Request Submission

Response Handling

Request Submission

Response Handling

Request Values
Response Values