Apple Pay Web on Core via eProtect Integration Method

Document created by gjsissons on Feb 2, 2017Last modified by gjsissons on Feb 2, 2017
Version 6Show Document
  • View in full screen mode

 

This document is being actively revised - please check back soon!

 

Overview

 

From a payments integration perspective, Apple Pay on the Web is similar to Apple Pay In-App.

Apple Pay on the Web allows you to potentially reach a larger audience however, since consumers are not required to download an iOS App to pay with Apple Pay. Rather, consumers with appropriate Apple devices can pay directly from their Safari browser with a single touch.

 

For an overview of Apple Pay on the Web, please check out this video from the 2016 Apple Worldwide Developer Conference.

You can download a presentation here that explains in detail how Apple Pay on the Web works.

 

Although there are multiple integration approaches for a Vantiv merchant wishing to support Apple Pay on the Web, these instructions are focused toward Apple Pay on the Web using Vantiv's eCommerce platform with Vantiv's eProtect service. This is the easiest integration method for most merchants, and is recommended for new integrations.

 

Prerequisites

 

Supporting Apple Pay on the Web is reasonably straightforward for most merchants. The integration involves adding the Apple Pay JS framework to your existing eCommerce website. While there is development and testing work involved, the amount of effort is much less then building an iOS app.

  • Apple Pay on the Web will only work from iOS10 devices with a secure element connecting from the Safari browser. It can also be used with Safari from macOS 10.12 as long as you have a bluetooth connected iPhone or Apple Watch that can authorize a payment.
  • Ensure that you have reviewed the Apple Pay documentation specific to Apple Pay on the Web. Relevant links are provided here for convenience
  • If you are already integrated with Vantiv, you will want to make sure that you are supporting a version of LitleXML that supports Apple Pay in-app and Apple Pay on the Web payments. Depending on the version of LitleXML you are integrated with, the following minimum versions are supported:
    • LitleXML 8.30
    • LitleXML 9.10
    • LitleXML 10.5
  • While Vantiv has a sandbox that developers can use to get started and code payment transactions against our eCommerce environment, you will need to work with a Vantiv integration consultant. If you don't already have an assigned consultant, please Contact us so that we can assign a consultant to work with you. You can also send an e-mail at anytime to customerservice@litle.com to get connected with an integration consultant. The consultant will be able to provide you with test credentials for Vantiv's various test environments and provide credentials for Vantiv's eProtect service (if you don't already have them) that you will need in later steps below. Vantiv has different test environments including a sandbox, pre-live and post-live environment. You can learn more about these environments in Certification and Testing Environments.
  • Before starting and integration with Vantiv, it is a good idea to review our Onboarding FAQ.
  • Apple provides test cards that you can load into an Apple Pay Wallet for testing.  Please see this page for reference: - Apple Pay Sandbox Testing - Support - Apple Developer

 

Getting started

 

Before you can use Apple Pay on the Web, you'll need to obtain Apple Pay credentials and register your eCommerce website with Apple.

 

These steps are required regardless of your integration method and regardless of the payment provider you are dealing with.

 

Follow the guidelines provided by Apple here:

 

  • Website Registration and Verification for Apple Pay - Support - Apple Developer

 

You will need to have an Apple Developer Program account before you can proceed with these steps. You can learn about the program here.

 

The steps involved are:

 

  • Register a Merchant ID (if you are already using Apple Pay In-App payments you can use your existing Merchant ID)
  • Create a payment processing certificate or obtain a Certificate Signing Request (CSR) from Vantiv if Vantiv is decrypting the PKPaymentToken on your behalf
  • Register your SSL protected merchant domain with Apple
  • Configure a connection certificate for your merchant ID so that you can connect to Apple's servers.

 

The Apple documentation explains these steps in detail here.

 

Integration Approaches

 

Implementing Apple Pay on the Web follows a similar process regardless of the Vantiv platform you are integrating with.

 

In all cases you will be implementing the Apple Pay JS Framework for use in your web application. You can follow the Apple documentation for detailed instructions about implementing Apple Pay on the Web.

 

Differences in integration methods become more significant once your application needs to process the PKPaymentToken received from Apple Pay.

 

This guide describes the first integration approach (using eProtect) listed below, but a brief overview of differences by platform and integration method are covered below as well.

 

  • Apple Pay on the Web with Vantiv's Core platform using eProtect - If you are processing with the Vantiv Core platform, using eProtect is the easiest way to get up and running. eProtect will handle all the decryption and vaulting of the Apple Pay payment data for you. The remainder of the steps below assume that you are following this integration method.
  • Apple Pay Web for Enterprise Platform - If you are processing through our IBM RAFT or 610 platforms (known as Vantiv core), you may also decrypt the PKPaymentToken, and formulate the ISO message for Apple Pay.  We have sample Java code that can help you get started. You can learn more about this Apple Pay on the Web Integration Method here. Again, the procedures for process payments are identical for on-the-web and in-app payment scenarios.

Implementing Apple Pay on the Web

 

The Apple Pay JS documentation provides all the details needed to integrate Apple Pay on the Web into your eCommerce website. At a high level, an Apple Pay on the Web integration adds these steps:

 

  • At the point of checkout, your web application will use the JavaScript ApplePaySession.canMakePayments() or ApplePaySession.canMakePaymentsWithActiveCard() method to detect whether the client device can make a payment with Apple Pay.
  • Apple Pay will present a payment sheet to be displayed when the user clicks on the Apple Pay button
  • Apple Pay will perform merchant validation behind the scenes
  • On successful validation, Apple Pay will provide your application with a PKPaymentToken that can be used with Vantiv
  • Your code will pass the PKPaymentToken to eProtect in return for a low-value token, and use the low-value token to authorize a payment
  • After successfully processing a payment, your application will call the Apple Pay completePayment() method to close the session with Apple Pay

 

A short description of each step is provided below to provide more clarity. Please note the Apple Pay JS documentation provides additional examples of interfaces and various callbacks and exceptions that your code will be required to handle.

 

Detecting availability of Apple Pay on the Browser

 

Your application will use a JavaScript fragment like the one below to expose Apple Pay on the Web as a payment method only if the Apple Pay JS API is present and the Safari client is able to make payments (with an active card loaded in the Apple wallet).

 

Sample HTML and CSS to expose the Apple Pay buttons is provided in the ApplePaySession Class documentation.

 

if (window.ApplePaySession) {  
     var merchantIdentifier = 'merchant.com.canine-clothing';  
     var promise = ApplePaySession.canMakePaymentsWithActiveCard(merchantIdentifier);  
     promise.then(function (canMakePayments) {  
     if (canMakePayments)  
          showApplePayButtons();  
     });  
}  

 

Present an Apple Pay payment sheet

 

Once we've determined that the client can pay via Apple Pay, we construct an Apple Pay payment sheet as shown. Details are provided in the Apple Pay JS API ApplePaySession Class reference. Note that session.begin() can only be called in a response to a user action (for example within an onclick event).

 

// Presenting the payment sheet  
var paymentRequest = {  
     currencyCode: 'USD',  
     countryCode: 'US',  
     total: {  
          label: ‘Canine Clothing',  
          amount: '19.99'  
     },  
     supportedNetworks: ['amex', 'discover', 'masterCard', 'visa' ],  
     merchantCapabilities: [ 'supports3DS' ],  
     requiredShippingAddressFields: [ 'postalAddress' ]  
};  
var session = new ApplePaySession(1, paymentRequest);  
session.begin();   

 

Merchant Validation

 

Next, the Apple Pay JavaScript API calls your session's onvalidatemerchant() callback function to validate that the request is coming from a valid merchant.  The steps involved are explained in detail in the Apple Pay JS API ApplePaySession Class reference (see the section titled Merchant Validation). Additional required steps are not shown here for brevity.

 

session.onvalidatemerchant = function (event) {  
     var promise = performValidation(event.validationURL);  
     promise.then(function (merchantSession) {  
          session.completeMerchantValidation(merchantSession);  
     });  
}   

 

Payment authorization

 

onpaymentauthorized is automatically called when the user has authorized an Apple Pay payment, typically via a touchID on the Apple device. Details are provided in the Apple Pay JS API Reference. The event object passed contains the Apple Pay PKPaymentToken token.

 

This where the integration with Vantiv takes place. You will need to construct a function below (sendPaymentToken() or whatever you decide to call it) that sends the PKPaymentToken to Vantiv's eProtect service, retrieves a low-value token in response (a payPageRegistrationID) and uses that low-value token to complete an authorization.

 

Once the payment has been authorized by Vantiv, your website can call the completePayment() instance method for the Apple Pay session to complete the payment and dismiss the Apple Pay sheet. A simplified example is shown below

 

session.onpaymentauthorized = function (event) {  
     var promise = sendPaymentToken(event.payment.token);  
     promise.then(function (success) {  
          var status;  
          if (success)  
               status = ApplePaySession.STATUS_SUCCESS;  
          else  
               status = ApplePaySession.STATUS_FAILURE;  
            session.completePayment(status);  
            showConfirmation();  
     });  
}   

 

The steps above show the high level process from an Apple Pay on the web perspective.

 

In the sections that follow we delve into the specifics of how the application processes the payment with eProtect once the token is received via the onpaymentauthorized() callback.

 

How Apple Pay on the Web works with eProtect

 

In this scenario, the Vantiv eProtect Customer Browser JavaScript API controls the fields on your checkout page that hold sensitive card data. In an eProtect implementation that does not involve Apple Pay on the web, eProtect fields will include details like:

 

  • A credit card number
  • An expiry date
  • CVV details

 

Note that the Apple Pay on the Web integration will normally be implemented in addition to existing payment methods, so everything in the existing eProtect integration is still valid. The only difference is that your application may additionally expose Apple Pay as a more convenient payment method if the client device is able to support it.

 

If you are using eProtect presently on your eCommerce website, a JavaScript SendtoLitle() method similar to the example below is used to pass information to Vantiv's eProtect service in return for a low value token.

 

The litleRequest object is a JSON structure that contains your merchant credentials. formFields is a JSON structure that points to the fields on the presented checkout form that contain sensitive data.

 

new LitlePayPage().sendToLitle(litleRequest, formFields, submitAfterLitle, onErrorAfterLitle, onTimeoutAfterLitle, timeout)        

 

Your application will still need to call sendToLitle in this fashion when the client device does not support Apple Pay or the user does not select Apple Pay as the payment method. In addition to your existing eProtect integration, you will need to provide an alternate path in your code, that calls sendToLitle() with a different set of arguments in the case of an Apple Pay on the web transaction following the onpaymentauthorized() callback. Below we get more specific and explain in detail how the Apple Pay on the Web transaction is handled with eProtect.

 

What happens when the user clicks the Apple Pay button

 

When the cardholder clicks the Apple Pay button, communication is exchanged with Apple Pay via the Apple Pay JS API to obtain the PKPaymentToken. Specifically, the token will be passed to your application in the ApplePay JS onpaymentauthorized() call back that you supply associated with your Apple Pay session as explained above.

 

From this point forward, handling the transaction is similar to any other eProtect transaction except that you will pass the eProtect server a PKPayment token instead of card data.

 

The eProtect server returns a Registration ID (low-value token) and your server constructs the authorization message using that ID. See the Vantiv eProtect Integration Guide for JavaScript and HTML page examples.

 

The high-level steps are detailed below:

 

  1. When the consumer selects the Apple Pay option from your website, your site makes use of the Apple Pay JS Framework to request payment data from Apple Pay.
  2. When Apple Pay receives the call from your website and after the consumer approves the Payment Sheet (using Touch ID), Apple creates a PKPaymentToken using your public key. Included in the PKPaymentToken is a network (Visa, MasterCard, American Express, or Discover) payment token and a cryptogram.
  3. The Apple Pay JS API passes the Apple PKPaymentToken (defined in Apple documentation; please refer to https://developer.apple.com/library/ios/documentation/PassKit/Reference/PaymentTokenJSON/PaymentTokenJSON.html) to your website via the Apple Pay JS  onpaymentauthorized() callback
  4. Your native iOS application sends the PKPaymentToken to our secure server via an HTTPS POST (see Creating a POST Request for an Apple Pay Transaction on page 36) and eProtect returns a Registration ID.
  5. Your website forwards the transaction data along with the Registration ID to your order processing server, as it would with any eProtect transaction.
  6. Your server constructs/submits a standard authorization message call to the IBM or RAFT platform using the Registration ID in the PAN field.
  7. Using the private key, Vantiv decrypts the PKPaymentToken associated with the Registration ID and submits the transaction with the appropriate information to the card networks for approval.
  8. Vantiv sends the Approval/Decline message back to your system. This message is the standard format for an Authorization response and includes the Vantiv specific token which can be used for subsequent transactions.
  9. You return the Approval/Decline message to your website and call the completePayment() method for the Apple Pay on the Web session with the authorization status to appropriately close the Apple Pay on the web session.

 

A diagram of these steps is provided below:

 

eprotect_integration_diagram.png

 

 

Passing the PKPaymentToken to eProtect

 

As is the case with a regular eProtect integration involving card information, you will need to create a POST request via the eProtect JavaScript API to pass payment information to and request a payPageRegistrationId (low-value token).

 

In the case of an Apple Pay on the web integration, you will pass different information to eProtect. Specifically:

  • The fields passed will not need to include the ccNum, cvv2Num or bin fields since these are not needed for an Apple Pay transaction.
  • You will need to pass the PKPaymentToken received via the Apple Pay JS onpaymentauthorized callback  to Vantiv eProtect.

 

Construct your HTTPS POST using the components listed below. See the Sample Apple Pay POST Request and Sample Apple Pay POST Response below.

 

apple_pay_post.png

 

applepay_post_2.png

 

The following is an example POST to request a Registration ID for Apple Pay:

 

 

curl --verbose -H "Content-Type: application/x-www-form-urlencoded" -H "Host:MerchantApp"

-H "User-Agent:Litle/1.0 CFNetwork/459 Darwin/10.0.0.d3"

-d"paypageId=a2y4o6m8k0&reportGroup=*merchant1500&orderId=PValid&id=1234&applepay.data=HT

897mACd%2F%2FTpWe10A5y9RmL5UfboTiDIvjni3zWFtyy8dtv72RJL1bk%2FU4dTDlrq1T1V2l0TSnI%0APLdOnn

HBO51bt9Ztj9odDTQ5LD%2F4hMZTQj3lBRvFOtTtjp9ysBAsydgjEjcCcbnkx7dCqgnwgzuz%0Ay7bX%2B5Fo8a8R

KqoprkDPwIMWOC9yWe7MQw%2FboM5NY2QtIcIvzbLFcYUxndYTg0IXNBHNzsvUOjmw%0AvEnMhXxeCH%2BC4KoC6M

EsAGK5rH1T5dSvTZzHF5c12dpsqdI73%2FBk6qEcdlT7gJKVmyDQC%2FNFxJ0X%0AF993Of6ejQDJq6BZsz8X7kYC

yJdI%2FPFJPZp4e3L%2FtCsBDUTJAgFLt2xF8HWaPoW8psILOGCCvJQm%0ATR1m7ODtSChaWOb7eYm1BpNiD3wkCH

8nmIMrlnt3KP4SeQ%3D%3D&applepay.signature=MIAGCSqGSIb3DQEHAqCAMIACAQExDzANBglghkgBZQMEAgE

FADCABgkqhkiG9w0BBwEAAKCAMIICvzCCAmWgAwIBAgIIQpCV6UIIb4owCgYIKoZIzj0EAwIwejEuMCwGA1UEAwwl

QXBwbGUgQXBwbGljYXRpb24gSW50ZWdyYXRpb24gQ0EgLSBHMzEmMCQGA1UECwwdQXBwbGUgQ2VydGlmaWNhdGlvb

iBBdXRob3JpdHkxEzARBgNVBAoMCkFwcGxlIEluYy4xCzAJBgNVBAYTAlVTMB4XDTE0MDUwODAxMjMzOVoXDTE5MD

UwNzAxMjMzOVowXzElMCMGA1UEAwwcZWNjLXNtcC1icm9rZXItc2lnbl9VQzQtUFJPRDEUMBIGA1UECwwLaU9TIFN

5c3RlbXMxEzARBgNVBAoMCkFwcGxlIEluYy4xCzAJBgNVBAYTAlVTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE

whV37evWx7Ihj2jdcJChIY3HsL1vLCg9hGCV2Ur0pUEbg0IO2BHzQH6DMx8cVMP36zIg1rrV1O%2F0komJPnwPE6O

B7zCB7DBFBggrBgEFBQcBAQQ5MDcwNQYIKwYBBQUHMAGGKWh0dHA6Ly9vY3NwLmFwcGxlLmNvbS9vY3NwMDQtYXBw

bGVhaWNhMzAxMB0GA1UdDgQWBBSUV9tv1XSBhomJdi9%2BV4UH55tYJDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBa

AFCPyScRPk%2BTvJ%2BbE9ihsP6K7%2FS5LMDQGA1UdHwQtMCswKaAnoCWGI2h0dHA6Ly9jcmwuYXBwbGUuY29tL2

FwcGxlYWljYTMuY3JsMA4GA1UdDwEB%2FwQEAwIHgDAPBgkqhkiG92NkBh0EAgUAMAoGCCqGSM49BAMCA0gAMEUCI

QCFGdtAk%2B7wXrBV7jTwzCBLE%2BOcrVL15hjif0reLJiPGgIgXGHYYeXwrn02Zwcl5TT1W8rIqK0QuIvOnO1THC

bkhVowggLuMIICdaADAgECAghJbS%2B%2FOpjalzAKBggqhkjOPQQDAjBnMRswGQYDVQQDDBJBcHBsZSBSb290IEN

BIC0gRzMxJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRMwEQYDVQQKDApBcHBsZSBJbmMu

MQswCQYDVQQGEwJVUzAeFw0xNDA1MDYyMzQ2MzBaFw0yOTA1MDYyMzQ2MzBaMHoxLjAsBgNVBAMMJUFwcGxlIEFwc

GxpY2F0aW9uIEludGVncmF0aW9uIENBIC0gRzMxJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0aG9yaX

R5MRMwEQYDVQQKDApBcHBsZSBJbmMuMQswCQYDVQQGEwJVUzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPAXEYQ

Z12SF1RpeJYEHduiAou%2Fee65N4I38S5PhM1bVZls1riLQl3YNIk57ugj9dhfOiMt2u2ZwvsjoKYT%2FVEWjgfcw

gfQwRgYIKwYBBQUHAQEEOjA4MDYGCCsGAQUFBzABhipodHRwOi8vb2NzcC5hcHBsZS5jb20vb2NzcDA0LWFwcGxlc

m9vdGNhZzMwHQYDVR0OBBYEFCPyScRPk%2BTvJ%2BbE9ihsP6K7%2FS5LMA8GA1UdEwEB%2FwQFMAMBAf8wHwYDVR

0jBBgwFoAUu7DeoVgziJqkipnevr3rr9rLJKswNwYDVR0fBDAwLjAsoCqgKIYmaHR0cDovL2NybC5hcHBsZS5jb20

vYXBwbGVyb290Y2FnMy5jcmwwDgYDVR0PAQH%2FBAQDAgEGMBAGCiqGSIb3Y2QGAg4EAgUAMAoGCCqGSM49BAMCA2

cAMGQCMDrPcoNRFpmxhvs1w1bKYr%2F0F%2B3ZD3VNoo6%2B8ZyBXkK3ifiY95tZn5jVQQ2PnenC%2FgIwMi3VRCG

wowV3bF3zODuQZ%2F0XfCwhbZZPxnJpghJvVPh6fRuZy5sJiSFhBpkPCZIdAAAxggFfMIIBWwIBATCBhjB6MS4wLA

YDVQQDDCVBcHBsZSBBcHBsaWNhdGlvbiBJbnRlZ3JhdGlvbiBDQSAtIEczMSYwJAYDVQQLDB1BcHBsZSBDZXJ0aWZ

pY2F0aW9uIEF1dGhvcml0eTETMBEGA1UECgwKQXBwbGUgSW5jLjELMAkGA1UEBhMCVVMCCEKQlelCCG%2BKMA0GCW

CGSAFlAwQCAQUAoGkwGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG9w0BCQUxDxcNMTQxMDAzMjE1NjQ

zWjAvBgkqhkiG9w0BCQQxIgQgg8i4X6yRAU7AXS1lamCf02UIQlpUvNPToXUaamsFUT8wCgYIKoZIzj0EAwIERzBF

AiBe17NGTuuk%2BW901k3Oac4Z90PoMhN1qRqnij9KNEb%2FXAIhALELZyDWw0fQM8t0pXO86gg9xXFz424rEMlJ0

1TM1VxhAAAAAAAA&applepay.version=EC_v1&applepay.header.applicationData=496461ea64b50527d2

d792df7c38f301300085dd463e347453ae72debf6f4d14&applepay.header.ephemeralPublicKey=MFkwEwY

HKoZIzj0CAQYIKoZIzj0DAQcDQgAEarp8xOhLX9QliUPS9c54i3cqEfrJD37NG75ieNxncOeFLkjCk%2FBn3jVxHl

ecRwYqe%2BAWQxZBtDyewaZcmWz5lg%3D%3D&applepay.header.publicKeyHash=zoV5b2%2BmqnMIxU9avTeq

Wxc7OW3fnKXFxyhY0cyRixU%3D&applepay.header.transactionId=23e26bd8741fea9e7a4d78a69f4255b3

15d39ec14233d6f1b32223d1999fb99f" https://request-prelive.np-securepaypage-litle.

com/LitlePayPage/paypage

 

Sample code is provided below. Note that the litleRequest structure includes an applepay field that contains the PKPaymentToken.

 

 <script>  
 ...  
  
 function sendTokenToLitle(token) {  
    setLitleResponseFields({"response":"", "message":""});  
  
        var litleRequest = {  
             "paypageId" : document.getElementById("request$paypageId").value,  
             "reportGroup" : document.getElementById("request$reportGroup").value,  
             "orderId" : document.getElementById("request$orderId").value,  
             "id" : document.getElementById("request$merchantTxnId").value,  
             "applepay" : token,  
             "url" : "https://request-prelive.np-securepaypage-litle.com"  
        };  
  
        var formFields = {  
            "accountNum" :document.getElementById('ccNum'),  
            "cvv2" :document.getElementById('cvv2Num'),  
            "paypageRegistrationId":document.getElementById('response$paypageRegistrationId'),  
            "bin" :document.getElementById('response$bin')  
        };  
  
    new LitlePayPage().sendToLitle(litleRequest, formFields, submitAfterLitle, onErrorAfterLitle, timeoutOnLitle, 15000);  
    return false;  
 }  
 ...  
  
</script>  

 

You can use the same callback functions that you already use for eProtect or create Apple Pay specific versions of those Callbacks.  (submitAfterLitle, onErrorAfterLitle and timeoutOnLitle).

 

Note that Apple Pay specific callback routines might be preferable since your application will need to call Vantiv with slightly different XML to authorize an Apple Pay transaction. On completion of the authorization, you'll also need to call the Apple Pay JS completePayment() method to advise Apple of the status of the transaction (Authorized, Declined etc.)

 

Just as you would in the case of a normal eProtect integration, your web browser will receive a payPageRegistrationId (low value token) as part of the response object when submitAfterLitle is called. The payPageRegistrationId is placed in a hidden browser form field and passed to the server via a POST method and used in the final step to authorize the payment transaction.

 

Step by step instructions and complete code examples are included in the Vantiv eProtect Integration Guide documentation.

 

Populating the ISO 8583 fields

 

Details are provided below about how to populate ISO 8583 fields with information extracted from the PKPaymentToken. For additional information, please consult the Vantiv ISO 8583 specification.

 

When populating the ISO 8583 fields for processing with Vantiv, the ECI indicator (eciIndicator) is mandatory and should always be populated. Populate the fields as shown below to enable Vantiv to interpret this as an Apple Pay / eCommerce transaction.

 

Payment Data Key ValueISO8583Field Note
applicationPrimaryAccountNumberField 2 – Primary Account Number
applicationExpirationDateField 14 – Date, ExpirationVantiv only supports YYMM, the merchant will need to truncate DD before submitting
currencyCodeField 49 – Currency Code, Transaction
transactionAmountField 4 – Amount, Transaction
CardholderNameN/AISO8583 does not have a corresponding field, nor is it needed to process the transaction
deviceManufacturerIdentifierN/AISO8583 does not have a corresponding field, nor is it needed to process the transaction
paymentDataTypeN/AISO8583 does not have a corresponding field, nor is it needed to process the transaction
paymentDataField 126See  detailed notes below about this field

 

Populating paymentData (Field 126 - eCommerce / MOTO indicator)

 

Vantiv has provided a network agnostic solution for the ApplePay cryptogram so that merchants do not have to identify what network the transaction belongs to

 

  • Attribute - LLL ans..999
  • This field must be present within all electronic commerce transactions. This field can also be used to distinguish various types of transactions for bill payment.
  • Syntax: <EC><I><DATA>
  • The field is made up of 4 Components
    • First two bytes = Length Indicator
    • Next two bytes <EC> = Secure Code transaction identifier (see table below)
    • Next one byte <I> = 6 (see second table below)
    • Next 20-40 bytes <DATA> = paymentData provided by Apple converted to hexadecimal. MasterCard and Visa result in 20 bytes hexadecimal and American Express results in 40 bytes hexadecimal.

Attachments

    Outcomes