Running the API in Postman

To help you get started with your integration, you can use the sample CardPointe Gateway API Integration Postman Collection, which includes a template of the API service endpoints.

The CardPointe Gateway API Integration collection also includes a sample Environment to help you get familiar with the API. See Configuring Your Postman Environment, below, for more information.

Click the button below to download the CardPointe Gateway API Integration collection:

Configuring Your Postman Environment

Environment variables allow you to autofill select fields with pre-configured values. For example, instead of manually specifying your merchant ID in the body of each request, you can set the {{merchantid}} variable to your specific MID.

Once you have received API credentials , you can configure the following variables to auto-fill your merchant-specific data in requests to the CardPointe Gateway API:

• site - Set this value to the site for the test or production environment.
• url - The {{url}} variable is used to set the base url (https://{{site}}.cardconnect.com/cardconnect/rest/) for the CardPointe Gateway RESTful web services. {{site}} is populated with the value you set for that variable.
• csurl - The {{csurl}} variable is used to set the url  (https://{{site}}.cardconnect.com/cardsecure/api/v1/ccn/tokenize) for the CardSecure tokenize REST web service. {{site}} is populated with the value you set for that variable.
• Authorization - Set this value to the Base64-encoded API credentials that you received. The {{Authorization}} variable is used in the header of every request.
• merchid - Set this value to your merchant ID (MID). The {{merchid}} variable is used in the body of most requests.

These variables are required in the header and body of most requests. The sample environment includes additional variables that you can configure when testing your integration.

Additionally, the sample collection includes test scripts, which gather specific values (such as token) from the response body, and dynamically update the corresponding environment variable.

To configure environment variables, do the following in Postman:

1. Click the gear icon to open the Manage Environments menu.
   
   
   
   
2. On the Manage Environments menu, enter your merchant-specific values for each variable.
   
   
   
   
3. Click Update.

Testing Your Integration

This guide provides information to help you develop and test your integrated application. Whether you are developing a new application, or maintaining an existing one, you should incorporate continuous testing in your SDLC.

Understanding the UAT Environment

You use the UAT (user acceptance testing) sandbox environment to test and validate your application. When you begin your application development and integration, you connect to the UAT instance of the CardPointe Gateway.

To connect to the UAT environment, your application uses the following URL:

https://<site>-uat.cardconnect.com/cardconnect/rest/<endpoint>

where <site> is the site name provided to you, and <endpoint> is a CardPointe Gateway service endpoint.

The UAT environment includes emulators that simulate the payment processing activities that occur in production. In this environment, you test with dummy data that is never sent to the payment processor. You should use test card numbers (for example, 4111 1111 1111 1111 or 4444 3333 2222 1111) and physical test cards. 

UAT Request Rate Limiting

In the UAT environment, requests to the following endpoints are rate-limited: 

• funding

• inquire

• profile

• settlestat

Requests to these UAT endpoints are limited to 20 transactions per minute (TPM), by IP address.

Responses from these endpoints in the UAT environment include the following rate-limit header fields:

• X-Rate-Limit-Retry-After-Seconds: - Returned for unsuccessful HTTP 429 Too Many Requests responses when the limit has been reached. Specifies the seconds remaining before the limit resets.
• X-Rate-Limit-Remaining: - Returned for successful HTTP 200 OK responses. Specifies the number of requests available before the limit is reached.

Understanding UAT Responses

Data that you transmit to the UAT environment is never sent to the payment processing networks; instead, the CardPointe Gateway communicates with an emulator that simulates the payment processor that your merchant ID uses to process payments. The emulator mimics the behavior of the given processing host, and returns a response similar to what you would receive for a live transaction in the production environment.

CardPointe Gateway API responses returned in the UAT environment include fields and arrays in a randomized order. Additionally, UAT responses include dummy fields, arrays, and values. This is intended to help clients develop integrated software that dynamically parses the response data, rather than expecting fields to be present in static positions within the response object. 

Some specific situations, such as a network timeout and specific decline scenarios, require specific input to initiate. See Test Cases, below, for more information on these specific scenarios.

See Gateway Response Codes for a complete list of all possible response codes for the CardPointe Gateway and each processor.

Getting Started

To get started, you'll need to configure your application with the following information:

UAT Testing URL

The CardPointe Gateway includes a sandbox UAT environment for integration testing. Your application can target this environment at https://fts-uat.cardconnect.com/cardconnect/rest/.

UAT API Credentials

To authenticate your application, the CardPointe Gateway API uses Basic Authorization. You receive a username and password, which you must convert into a string (in the format username:password) and Base64-encode. Your application must then pass the encoded string in the Authorization header of every request.

To access the UAT sandbox environment use the following credentials:

• username: testing
• password: testing123

UAT Merchant ID

A CardPointe merchant ID (MID) is required in all API requests. To use your application to process live transactions, you will receive a unique production MID.

To develop and test your application, you can use the test MID 496160873888.

Using Test Payment Accounts

When testing in the UAT environment, you must use test cards (either physical cards or test card numbers).

UAT Test Card Data

The UAT Merchant ID is boarded to the First Data North UAT environment. If you are testing with this MID, or your own MID that is boarded to the North or Rapid Connect platform, you can use the following test card data to test card-not-present transactions.

The UAT Test Zip Codes section below contains information on testing AVS responses for First Data North, Rapid Connect, and additional platforms.

Physical Test Cards

Physical test cards allow you to test card-present payments.

You can obtain a complete set of EMV test cards from B2 Payment Solutions at the following URL:

https://b2ps.com/product-category/b2-payment-testing-products/

Test Cases

The following topics provide information for testing specific features to obtain responses that are otherwise not returned in the UAT environment.

Testing with Amount-Driven Response Codes

When testing your CardPointe Gateway or CardPointe Integrated Terminal integration in the UAT environment, you can use amount-driven response codes to emulate processor-specific authorization responses that you might encounter in the production environment. This allows you to receive and handle response codes that you would not otherwise encounter in your test environment.

All response codes returned in the production environment are received directly from the processor.

To return a specific response code, you make an authorization request with an amount in the $1000-$1999 range. You specify the desired response code using the last three digits (with a leading 0 for 2-digit response codes) of the whole-dollar amount (the amount excluding cents). For example, if you want to return RPCT respcode 332, "Account locked," make an authorization request for $1332.

The following example illustrates an authorization request for $1116.95. The amount value specified is 111695 (with the decimal implied), therefore, the whole-dollar amount is $1116.

The response includes the RPCT respcode 116, which indicates that the transaction was declined due to insufficient funds.

Testing Refund Authorizations

You can simulate a refund authorization response on the following UAT emulators:

• First Data North (FNOR)
• First Data Rapid Connect (RPCT)
• Chase Paymentech (PMT)

Similarly to testing specific authorization response scenarios using amount-driven responses, you can test individual refund response codes, by sending a partial refund request using an amount value that includes the desired response code.

To test a refund decline, do the following:

1. Run an authorization request including "capture":"y" and "amount":"2000.00" or greater.
2. Run a refund request including the retref from the authorization response and "amount":"1nnn.00", where nnn is the 2 (including leading 0) or 3-digit decline response code you want to receive.
   
   For example, to return a RPCT 500 "Decline" response, include "amount":"1500.00" in the refund request.

Testing Partial Authorizations 

You can simulate a partial authorization response on the following UAT emulators:

• First Data North (FNOR)
• First Data Rapid Connect (RPCT)
• Paymentech (Paymentech)
• Paymentech Tampa (PTAM)
• Vantiv (VANT)
• Worldpay (VPS)

To simulate a partial authorization, submit an authorization request using "account":"4387750101010101" and "amount":"6.00" or greater.

The following responses are returned:

For example:

Testing AVS Response Codes

In order to test AVS response codes that you will encounter in the production environment, the UAT environment is configured to simulate various AVS responses when the last three characters of the postal code matches a specific value.

To force a specific AVS response, review the UAT Test Zip Codes available in the UAT Test Card Data section of this guide. Then submit an authorization request using the last three characters of the postal code meant to generate that AVS response. To illustrate this, the example below uses a zip code ending in 112 to emulate "avsresp": "N" in the response.

Testing CardPointe Gateway Timeouts

Because the UAT environment does not communicate with the processing hosts, your application can not encounter a time out scenario. In production, when the CardPointe Gateway communication with the processor times out, the Gateway returns an auth response object that includes "respcode":"62" and "resptext":"Timed out"

If you want to test your application's ability to handle a time out response, you can send an auth request using one of the following test card numbers:

• Visa: 4999006200620062
• MC: 5111006200620062
• Discover: 6465006200620062

The response includes the PPS respcode 62, which indicates that the transaction was declined due to a communication timeout between the CardPointe Gateway and processor host.

Processing ACH Payments

This guide provides guidance for accepting Automated Clearing House (ACH) payments using the CardPointe Gateway API. ACH payments, also called e-check payments, are a common payment method for recurring payments as well as telephone and mail orders.

Unlike credit card payments, when a customer authorizes an ACH payment, the funds are withdrawn directly from his or her bank account. This process can take several days, so you should include a monitoring process in your integration to verify the status of the transaction.

To accept ACH payments, you must capture and handle the customer's bank account and routing number. While you can capture this information and pass it directly to the CardPointe Gateway in an authorization request, it is a best practice to instead capture this information and tokenize it using a CardSecure-integrated web form.

Using a Web Form to Gather and Tokenize ACH Payment Data

To ensure the security of your customers' data, as well as your PCI compliance, it is recommended that you use a customer-facing web form, integrated with CardSecure, to capture and tokenize bank account and routing information.

When using a web form to capture and tokenize customer bank account information, include separate fields for the routing number and account number. Send these fields in a CardSecure tokenization request in the format
"account" : "<routing number>/<account number>"

For example:

"account" : "123456789/1234123412341234"

CardSecure returns a token representing the ACH account information, which you can then use to make an authorization request to the CardPointe Gateway.

Making an ACH Authorization Request

To process an ACH payment, you make an authorization request using the CardPointe Gateway API. In addition to the fields required for all authorization requests, you must include the following information:

The following example illustrates an ACH authorization request and response:

Verifying ACH Transactions

ACH transactions typically take several business days to process and settle, therefore, it is a best practice to periodically check the status of the transaction to ensure that it is successfully processed and that you are credited for the authorized amount.

You can use the CardSecure Gateway API to programmatically verify the transaction status using the inquire and funding service endpoints.

Using the Inquire Endpoint

The inquire endpoint provides information on completed authorizations.

You can use the inquire endpoint if you have the retrieval reference number (retref) from the authorization response. If you don't have the retref, but you included a unique order ID in the authorization request, then you can use the inquireByOrderId endpoint instead.

The inquire response includes a settlement status (setlstat) field that displays the settlement status of the transaction. Note that the settlement status initially displays "Queued for Capture" for ACH transactions, and the value is updated once the batch is transmitted. If "setlstat" : "rejected" you can use the funding endpoint to gather more detailed information.

Using the Funding Endpoint

The funding endpoint provides additional useful information for ACH transactions. Specifically, you can use the funding endpoint to retrieve an ACH return code (achreturncode), which provides additional information for rejected ACH transactions.

To use the funding endpoint, you make a request using the merchant ID and the date of the funding event that included the transaction. The funding endpoint returns an array of transaction details for that date.

Use the retref for the ACH transaction to locate it in the txns node of the response data. For ACH transactions, the response includes an achreturncode field that includes a specific code that explains the reason for the rejection.

The following table describes the possible ACH return code values.

Testing ACH Authorizations

To test ACH authorizations, you can use the test Merchant ID (MID) 496160873888 in the CardPointe Gateway's UAT environment. This MID uses a routing rule to detect when "accttype" : "ECHK" and then routes ACH transactions through a separate, linked MID, 542041.

This configuration allows you to dedicate separate merchant accounts to processing credit/debit and ACH transactions, which can be helpful for testing and reporting purposes. Contact Support if you want to configure a dedicated MID for processing ACH transactions.

Scheduling Recurring Payments

This guide provides information for extending your existing CardPointe Gateway API integration to add recurring billing to your payment methods.

To do this, you can use an application scheduler, like Cron, to create a schedule to run recurring transactions. The scheduled job can initiate an authorization request to the CardPointe Gateway using tokenized payment data or a stored profile.

This method gives you complete control over your recurring payment schedule with a simple API integration.

How it Works

The following process provides a general overview of the steps required to set up a recurring payment schedule using the CardPointe Gateway. depending on your integration and business needs, your procedure may vary.

Ensure that you review and comply with the card brand requirements for obtaining consent to store and reuse cardholder data. See the Visa and Mastercard Stored Credential Framework Mandate guide for detailed information.

1. Tokenize the customer's payment data.
   
   Depending on your existing integration, there are several ways to tokenize payment data.
   
   For example, you can:
   • Use the customer’s clear PAN or ACH payment data to make a CardPointe Gateway API authorization request. The response returns a token for the account.
     
     Note: You should only programmatically handle and tokenize clear payment account numbers (PANs) if your business is a registered PCI Level 1 or Level 2 certified merchant. If you are not already certified for compliance with the Payment Card Industry's standards and guidelines for handling sensitive account data, see https://www.pcisecuritystandards.org/ for more information.
     
     Optionally, do the following: 

     • Include ”capture” : “y” to accept an initial payment.
     • include ”profile” : “y” to store the customer’s data in a profile to use in future requests.
   • Gather and tokenize the payment card data using the Hosted iFrame Tokenizer.
   • Use a CardPointe Integrated Terminal and the Terminal API readCard or readManual service endpoint.
2. Store the token for reuse.
   
   You can either store tokens and customer data in your own database, or you can use the CardPointe Gateway API’s profile service endpoint to create and store customer profiles in the CardPointe Gateway's secure vault. You can skip this step if you created a profile in step 1.
   
   
3. Gather your billing requirements.
   
   Determine the start date and length of the billing plan, the payment amount and frequency, and any additional information that you'll need to include in your requests.
   
   
4. Build your Cron job to schedule authorization requests to the CardPointe Gateway API.

Printing Receipts Using Authorization Data

This guide provides information for integrators who want to use authorization response data to print receipts from an integrated POS printer.

Receipt Rules and Requirements

This topic provides general best practices and integration details for printing receipts and capturing cardholder signature data; however, each card brand provides specific rules and requirements. You should understand and follow the receipt guidelines for the card brands that you accept.

Consult the following card brand guidelines for detailed information:

• MasterCard: https://www.mastercard.us/content/dam/mccom/global/documents/transaction-processing-rules.pdf
• Visa: https://usa.visa.com/dam/VCOM/download/about-visa/visa-rules-public.pdf

Additionally, receipt requirements vary depending on the card type. For example, receipts generated for EMV (chip and contactless) card transactions must include specific EMV tag data returned in the authorization response. Ensure that you understand the requirements for accepting both EMV and MSR (magnetic-stripe) cards as determined by the card brands.

Understanding Receipt Data

When an authorization is successfully approved and processed by the CardPointe Gateway, the authorization response payload includes important transaction details that you can capture and print on a receipt.

In general, a receipt must include:

• transaction details from the authorization response
• merchant account information and additional transaction details returned in the receipt object
• EMV tag data returned in the EMV tag object, if the card used was an EMV (chip or contactless) card.

Authorization Response Data

A successful authorization response includes the following fields. You should include the highlighted fields on your receipts.

EMV Tag Data

If the card used in the authorization request was an EMV (chip or contactless) card, then the response data includes an emvTagData object with the following fields:

Receipt Data

The receipt object is an optional set of fields that provides additional merchant and order details in the authorization response. 

The merchant account information is populated using the merchant properties configured for the MID.

Additionally, this object includes additional transaction details from the authorization response. You can optionally include a custom order note (orderNote) and item details (items), by including a userFields object in the authorization request.

You can specify the following fields in a userFields object to include an order note or item details, or to override the merchant properties:

Each value can be any string and the total length of user defined fields (URL/JSON-encoded) is limited to 4000 bytes. See the description of userFields in the CardPointe Gateway API documentation for more information.

A successful authorization response includes a receipt object with the following fields:

Printing a Receipt

To print a receipt from your custom integration, use the fields described in Understanding Receipt Data to build your receipt template.

The following example illustrates a receipt template (left) and a receipt populated with data retrieved from the authorization response (right).

Handling Timed-out Transactions

This guide provides best practices for handling CardPointe Gateway API timeout errors. The Gateway API supports synchronous communication; therefore, your application must make requests and expect responses in sync with the CardPointe Gateway services.

If you are a developer integrating your point-of-sale software with the CardPointe Gateway API, it is important for you to understand how long the steps of the payment process can take, so your software can interact accordingly. The following information should guide you on how long to wait for a response, and actions to take if one is not returned.

CardPointe Gateway Authorization Timeout (32 Seconds)

When you use the CardPointe Gateway API's auth endpoint, to make an authorization request, the Gateway sends the request to the payment processing network and allows 31 seconds for a response. If the Gateway does not receive a response, then the request times out at the 32 second mark and returns a "Timed Out" response.

Handling CardPointe Gateway Timeouts

Whether your application is using the Terminal API authCard request, or the CardPointe Gateway API auth request, it should be designed to handle the following scenarios:

1. A "Timed out" response returned successfully (HTTP 200) from the CardPointe Gateway auth endpoint or the Terminal API authCard endpoint.
2. No response returned successfully from the CardPointe Gateway auth endpoint.

In this case, a response, including a retref for the transaction, is returned. The response includes "respstat": "B" which always means "Retry." The transaction attempt should be tried again.

If you need to reference the details of any particular transaction attempt, supply valid retref and merchid values in an inquire request.

In some cases, retry attempts will also fail. In the event of multiple retry failures, check status.cardconnect.com for reports of system-wide issues.

No Response Returned

This scenario may include, but is not limited to, an HTTP Status 408 Request Timeout.

In this case, your application can not determine whether or not the transaction was successful.

As a safeguard against losing record of the transaction attempt from your system, it is strongly recommended that you supply a unique order ID for every authorization request made to the API.

If you included an order ID in the original authorization request, then you can use the following Gateway API service endpoints to inquire on or void the transaction record:

• inquireByOrderid
  
  The inquireByOrderid endpoint is used to look up a transaction record using the order ID supplied in the original authorization request. If the supplied order ID is found, then the same payload returned in the inquire response is provided.
  
  If the original authorization request was successful, the response includes the transaction details, including the retref. You can then use the retref to make a subsequent void or capture call.
  
  If the original authorization request was unsuccessful, the response includes PPS respcode 29, Txn not found. This response indicates that the authorization request timed out before being processed by the CardPointe Gateway, and you should retry the authorization request. 
  
  
• voidByOrderId
  
  The voidByOrderId endpoint is used to look up and void a transaction record using the order ID supplied in the original authorization request. If the supplied order ID matches a transaction record, the authorization is voided and a void response is returned. See the voidByOrderId description for more information.
  
  voidByOrderId should be used in the event that no response is returned by an inquireByOrderId request, or if no look up is required at all.
  
  Note: You should attempt the voidByOrderid request three times (3x) to ensure that the transaction is voided, despite not receiving a response to indicate that the request was successful.

See the CardPointe Gateway API for information on the inquireByOrderid, voidByOrderId, and capture service endpoints.

Manually Managing Gateway Batches

This guide provides information for using the CardPointe Gateway API's openbatch and closebatch service endpoints to manually open and close Gateway batches, and the settlestatByBatchSource endpoint to retrieve settlement details for a batch. 

Using the openbatch Endpoint

A call to the openbatch service endpoint opens a new batch associated with the supplied merchid. The batchsource is used to supply a batch identifier to logically link multiple batches together across merchant IDs. A batch contains one merchid.

Exercise caution when specifying a batchsource value. The CardPointe Gateway does not validate or use the value and it is possible for more batches to be grouped if the same batchsource is used by mistake; therefore it is a best practice to use unique batch source values, and to develop a system for categorizing grouped transactions accurately.

Additionally, the batchsource value in an openbatch request must match the batchsource value in the authorization or capture request for the transaction that you want to include in the created batch.

openbatch URL

openbatch Request

Fields in bold are required.

openbatch Response

Using the closebatch Endpoint

A call to the closebatch service endpoint attempts to close the batch identified by the merchid and batchid. Provide a batchid to attempt to close a specific batch. If no batchid is supplied, the open batch with the lowest batchid is closed.

closebatch URL

closebatch Request

Fields in bold are required.

closebatch Response

Using the settlestatByBatchSource Endpoint

A call to the settlestatByBatchSource service endpoint returns the settlement status and details for all transactions in a given batch, identified by the batchsource.

settlestatByBatchSource URL

settlestatByBatchSource Request

Fields in bold are required.

settlestatByBatchSource Response

Using the Batch Authorization Service to Process Batch Files

This guide provides information for using the CardPointe Gateway's Batch Authorization Service (BAS) to submit batch files for authorization processing. 

The request file submitted to BAS will contain all required data elements within an Authorization Request to the CardPointe Gateway. BAS collects the supplied data and submits all requests on behalf of the client. A response file is returned, containing data from the associated Authorization Response.

Client Onboarding Checklist

1. Obtain the CardPointe Gateway PGP public key. Clients must encrypt all request files using this key.
   
2. Send your client pgp public key to integrationdelivery@fiserv.com. Your public key will be used to encrypt response files.
3. Obtain your SFTP credentials required to submit requests and poll for response files.
4. Obtain your CardPointe Gateway API URL and credentials from.
   

Supported Authorization Types

The Batch Authorization Service supports all data elements that the CardPointe Gateway Authorization Service supports.

PGP Keys

All files that are submitted to or retrieved from Secure Exchange must be PGP encrypted. This requires two PGP key pairs:

• Request keypair - We hold the private key and you download the public key. You must use this key to encrypt all BAS request files before uploading them to Secure Exchange.
• Response keypair - You hold the private key and send the public key to us. The Secure Exchange service uses your key to encrypt all BAS response files.

Click below to download the public PGP keys for the UAT and Prod environments:

Note that these keys are "armored." Run the "gpg --dearmor" command to de-armor the keys.

For example:

$ gpg --dearmor < secureexhange_uat.txt > secureexchange_uat.gpg

BAS Request File Specifications

The Batch Authorization Service supports all fields and data elements that the CardPointe Gateway Authorization Service supports.

BAS Request File Name

The BAS Request file name must be unique, and must end with .csv.pgp.

We recommend the following format:

<merchantname>_<date>_<sequence#>.csv.pgp

Where:

• <merchantname> is your merchant ID or other identifier.

• <date> is the date of the batch.

• <sequence#> is a unique identifier that you assign to the batch.

• .csv.pgp is required.

• The file name must not include spaces.

For example:

mystore_20210715_1.csv.pgp

Sample BAS Request File

merchid,orderid,accttype,account,expiry,amount,capture,currency,email,name,address,address2,city,region,country,postal,phone,company,taxexempt,items,invoiceid,ponumber,shiptozip,shipfromzip,shiptocountry,orderdate,taxamnt,frtamnt,dutyamnt,discamnt,waiver,fee_value,fee_format,gsacard081800000001,1000102424,VISA,9404077753845057,1299,100,Y,USD,test@test.com,name1,add1,add2,city1,,US,19020,,,,Y,"unitcost='1.00',description='desc with no comma',uom='lb'|unitcost='1.00',description='desc with,comma',uom='lb'",,,,,,,,,,,Y,,,Y081800000001,1000102425,VISA,9404077753845057,1299,100,N,USD,,name1,add1,add2,,,,19020,111-111-11111,,,,"unitcost='1.00',description='desc with no comma',uom='lb'",,,,,,,,,,,,,,081800000001,1000102426,VISA,9404077753845057,1299,100,N,USD,test@test.com,,add1,,city1,,US,19020,,,,,"unitcost='1.00',description='desc with no comma',uom='lb'|unitcost='1.00',description='desc with,comma',uom='lb'",,,,,,,,,,,,,,081800000001,1000102427,VISA,9404077753845057,1299,100,Y,USD,test@test.com,name1,,add2,,,US,19020,111-111-11111,,,N,,,,,,,,,,,,,,,

BAS Request Fields

Fields in bold are required.

Fields with a # indicate these fields can be used as part of a profile. See the CardPointe Gateway API profile description for more information.

Capture Level 2 Data

If available, the Level 2 fields can be provided in the capture request and should be provided for corporate or purchase cards to qualify for improved interchange rates.

Many Level 2 protocols refer to a "Customer Code" described as "an identifier the customer would recognize". The CardPointe Gateway populates this field with the ponumber. If the ponumber is not provided, then the orderid from the authorization request is used. If neither the ponumber or the orderid is available, the CardPointe Gateway Retrieval Reference Number (retref) is used.

The Level 2 protocol also requires certain fields about the merchant, such as Postal Code and Tax Identification Number. These fields are filled from the configuration table created during the merchant boarding process.

Capture Level 3 Data

If available, Level 3 line item data can be sent with the capture request, particularly for commercial or corporate payment cards. To qualify for Level 3 Interchange rates, Level 2 data (described above) must also be provided.

Level 3 data includes additional Order Level items such as freight and discount amount, as well as information from each line item of the order. These are stored as an array in the items field.

Items Field for BAS

The items field can be passed as a pipe-delimited string, or as a JSON array.

If using a pipe-delimited string:

• The Items field must be enclosed in double quotation marks (").

• Each item must be separated by a pipe delimiter (|).

• Elements in each item must be a key='value' pair.

• Elements in each item must be separated by a comma (,).

• Each value must be enclosed in single quotation marks (').

• Values containing a single quote (') must be escaped with a backslash (\).

  For example:

  description='desc with a single quote\''

• Values containing a comma (,) must also be enclosed in double quotation marks (").

  For example:

  "unitcost='1.00',description='desc with no comma',uom='lb'|unitcost='1.00',description='desc with,comma',uom='lb'"

If using a JSON array:

• The array must be enclosed in double quotation marks (" ").

• Each item in the array must be enclosed in curly braces ({ })

• Each key-value pair must be formatted as ""key"":""value"".

• Each key-value pair must be separated by a comma (,).

  For example:

  "[{""uom"":""lb"",""unitcost"":""1.00"",""description"":""desc with no comma""},{""uom"":""lb"",""unitcost"":""1.00"",""description"":""desc with,comma""}]"

Line Item Records

BAS Response File Specifications

BAS response files are pgp-encrypted with the key that you provided.
Response files will return one CardPointe Gateway response per line.

BAS Response File Name

The response file name matches the corresponding request file name with the extension ".done" appended.

For example:

<name>_<yymmdd>_<seq>.csv.pgp.done

Sample BAS Response File

id,status,message,orderid,retref,amount,resptext,commcard,cvvresp,batchid,avsresp,respcode,merchid,token,authcode,respproc,respstat,account1,DONE,,1000102424,2345676543,2.00,Approval,C ,P,543,A,00,081800000001,9404077753845057,PPS001,FNOR,A,94040777538450572,DONE,,1000102425,2345676543,3.00,Approval,C ,P,543,A,00,081800000001,9404077753845057,PPS001,FNOR,A,94040777538450573,ERROR,401 Un-Authorized,10001024264,DONE,,1000102427,2345676543,4.00,Declined,C ,P,543,U,00,081800000001,9404077753845057,PPS063,FNOR,C,94040777538450575,LOAD_ERROR,IOException reading next record: java.io.IOException: (line 2) invalid char between encapsulated token and delimiter

BAS Response File Fields

Submitting a Batch File

You submit request files and retrieve response files using Secure Exchange, via SFTP. When you log in to Secure Exchange you have access to three directories: /request, /response, and /dlc (dead-letter channel).

The following procedure describes each folder's purpose:

1. You upload an encrypted request file into the /request directory.
   
   BAS decrypts the file and runs authorization requests, logging each response in a new response file.
   
2. You poll the server for encrypted responses files in the /response directory.
3. If an error occurs when attempting to decrypt the pgp file, the encrypted request file is placed in the /dlc directory.
   
   Contact Support if you encounter this scenario.

Viewing Batch File Transactions in CardPointe

To view reporting details for processed batches in CardPointe, do the following:

1. Log in to CardPointe and access the merchant account.
2. Click Reporting in the menu bar, and select the Transactions tab.
3. Click the Front End column header and select SecureExchange to display the transactions processed by BAS.

See the CardPointe Web App support page for more information on using CardPointe.