Google Pay

Countries & currencies

Supported countries

• Albania
• Algeria
• American Samoa
• Angola
• Antigua and Barbuda
• Argentina
• Australia
• Austria
• Azerbaijan
• Bahrain
• Belarus
• Belgium
• Brazil
• Bulgaria
• Canada
• Chile
• Colombia
• Croatia
• Czech Republic
• Denmark
• Dominican Republic
• Egypt
• Estonia
• Finland
• France
• Germany
• Greece
• Hong Kong
• Hungary
• India
• Indonesia
• Ireland
• Israel
• Italy
• Japan
• Jordan
• Kazakhstan
• Kenya
• Kuwait
• Lebanon
• Lithuania
• Luxembourg
• Malaysia
• Mexico
• Netherlands
• New Zealand
• Norway
• Oman
• Pakistan
• Panama
• Peru
• Philippines
• Poland
• Portugal
• Qatar
• Romania
• Russia
• Saudi Arabia
• Singapore
• Slovakia
• South Africa
• Spain
• Sri Lanka
• Sweden
• Switzerland
• Taiwan
• Thailand
• Turkey
• Ukraine
• United Arab Emirates
• United Kingdom
• United States Minor Outlying Islands
• United States
• Uruguay
• Vietnam

Supported currencies

• Albanian lek (ALL)
• Algerian dinar (DZD)
• Angolan kwanza (AOA)
• Argentine peso (ARS)
• Armenian dram (AMD)
• Aruban florin (AWG)
• Australian dollar (AUD)
• Azerbaijani manat (AZN)
• Bahamian dollar (BSD)
• Bahraini dinar (BHD)
• Bangladeshi taka (BDT)
• Barbados dollar (BBD)
• Belarusian ruble (BYN)
• Belize dollar (BZD)
• Bermudian dollar (BMD)
• Bhutanese ngultrum (BTN)
• Boliviano (BOB)
• Bosnia and Herzegovina convertible mark (BAM)
• Botswana pula (BWP)
• Brazilian real (BRL)
• Brunei dollar (BND)
• Bulgarian lev (BGN)
• Burundian franc (BIF)
• Cambodian riel (KHR)
• Canadian dollar (CAD)
• Cape Verde escudo (CVE)
• Cayman Islands dollar (KYD)
• CFA franc BCEAO (XOF)
• CFA franc BEAC (XAF)
• CFP franc (franc Pacifique) (XPF)
• Chilean peso (CLP)
• Chinese yuan (CNY)
• Colombian peso (COP)
• Comoro franc (KMF)
• Congolese franc (CDF)
• Costa Rican colon (CRC)
• Croatian kuna (HRK)
• Cuban peso (CUP)
• Czech koruna (CZK)
• Danish krone (DKK)
• Djiboutian franc (DJF)
• Dominican peso (DOP)
• East Caribbean dollar (XCD)
• Egyptian pound (EGP)
• Eritrean nakfa (ERN)
• Ethiopian birr (ETB)
• Euro (EUR)
• Falkland Islands pound (FKP)
• Fiji dollar (FJD)
• Gambian dalasi (GMD)
• Georgian lari (GEL)
• Ghanaian cedi (GHS)
• Gibraltar pound (GIP)
• Guatemalan quetzal (GTQ)
• Guinean franc (GNF)
• Guyanese dollar (GYD)
• Haitian gourde (HTG)
• Honduran lempira (HNL)
• Hong Kong dollar (HKD)
• Hungarian forint (HUF)
• Icelandic króna (ISK)
• Indian rupee (INR)
• Indonesian rupiah (IDR)
• Iranian rial (IRR)
• Iraqi dinar (IQD)
• Israeli new shekel (ILS)
• Jamaican dollar (JMD)
• Japanese yen (JPY)
• Jordanian dinar (JOD)
• Kazakhstani tenge (KZT)
• Kenyan shilling (KES)
• Kuwaiti dinar (KWD)
• Kyrgyzstani som (KGS)
• Lao kip (LAK)
• Lebanese pound (LBP)
• Lesotho loti (LSL)
• Liberian dollar (LRD)
• Libyan dinar (LYD)
• Lithuanian litas (LTL)
• Macanese pataca (MOP)
• Macedonian denar (MKD)
• Malagasy ariary (MGA)
• Malawian kwacha (MWK)
• Malaysian ringgit (MYR)
• Maldivian rufiyaa (MVR)
• Mauritanian ouguiya (MRO)
• Mauritian rupee (MUR)
• Mexican peso (MXN)
• Moldovan leu (MDL)
• Mongolian tugrik (MNT)
• Moroccan dirham (MAD)
• Mozambican metical (MZN)
• Myanmar kyat (MMK)
• Namibian dollar (NAD)
• Nepalese rupee (NPR)
• Netherlands Antillean guilder (ANG)
• New Taiwan dollar (TWD)
• New Zealand dollar (NZD)
• Nicaraguan córdoba (NIO)
• Nigerian naira (NGN)
• Norwegian krone (NOK)
• Omani rial (OMR)
• Pakistani rupee (PKR)
• Panamanian balboa (PAB)
• Papua New Guinean kina (PGK)
• Paraguayan guaraní (PYG)
• Peruvian nuevo sol (PEN)
• Philippine peso (PHP)
• Polish zloty (PLN)
• Pound sterling (GBP)
• Qatari riyal (QAR)
• Romanian new leu (RON)
• Russian ruble (RUB)
• Rwandan franc (RWF)
• Saint Helena pound (SHP)
• Salvadoran Colon (SVC)
• Samoan tala (WST)
• São Tomé and Príncipe dobra (STD)
• Saudi riyal (SAR)
• Serbian dinar (RSD)
• Seychelles rupee (SCR)
• Sierra Leonean leone (SLL)
• Singapore dollar (SGD)
• Solomon Islands dollar (SBD)
• Somali shilling (SOS)
• South African rand (ZAR)
• South Korean won (KRW)
• Sri Lankan rupee (LKR)
• Surinamese dollar (SRD)
• Swazi lilangeni (SZL)
• Swedish krona/kronor (SEK)
• Swiss franc (CHF)
• Tajikistani somoni (TJS)
• Tanzanian shilling (TZS)
• Thai baht (THB)
• Tongan paʻanga (TOP)
• Trinidad and Tobago dollar (TTD)
• Tunisian dinar (TND)
• Turkish lira (TRY)
• Turkmenistani manat (TMT)
• Ugandan shilling (UGX)
• Ukrainian hryvnia (UAH)
• United Arab Emirates dirham (AED)
• United States dollar (USD)
• Uruguayan peso (UYU)
• Uzbekistan som (UZS)
• Vanuatu vatu (VUV)
• Venezuelan bolívar (VEF)
• Vietnamese dong (VND)
• Yemeni rial (YER)
• Zambian kwacha (ZMW)
• Zimbabwe dollar (ZWD)

Integration

Avec Google Pay™, vos clients peuvent acheter des biens/services avec une carte de crédit ou de débit stockée dans leur compte Google. Que ce soit depuis leurs appareils Android ou sur Internet, le processus de paiement est beaucoup plus simple : Google Pay™ affiche une feuille de paiement qui sélectionne la méthode de paiement par carte préférée que les acheteurs confirment.
Regardez la vidéo pour voir comment les acheteurs paient avec Google Pay™.

Pour bénéficier d'un transfert de responsabilité lors de l'utilisation de Google Pay™, vous devez authentifier la transaction avec 3-D Secure.
Notre plateforme vous propose deux types d'intégration pour votre entreprise :

• Google Pay™ sur votre propre page de paiement
• Google Pay™ dans l'application

Retrouvez un aperçu général dans le chapitre "Process flows".

Google Pay™ sur votre propre page de paiement

Utilisez notre SDK JavaScript pour intégrer Google Pay™ avec le bouton Google Pay™ directement dans votre propre page de paiement. Dans ce cas, vous devez ouvrir une page Google Pay™ et obtenir le token de paiement que Google chiffrera pour vous avec notre clé publique.
Une fois que vous avez reçu le token de paiement, vous devez nous l'envoyer en utilisant notre appel d'API Create Payment via l'API Serveur pour compléter le paiement. Après cette étape, nous nous occuperons du déchiffrement pour vous.
Pour ce faire, vous devez :

• Ouvrir une page Google Pay™.
• Obtenir le token de paiement que Google chiffre pour vous avec notre clé publique en utilisant l'API de Google.
• Envoyer le token de paiement en utilisant notre API CreatePayment avec l'un de nos SDK Serveur afin que nous puissions gérer le déchiffrement pour vous.

Ce mode d'intégration vous offre les avantages suivants :

• Meilleure visibilité du bouton Google Pay™ sur votre site web pour une conversion plus élevée.
• Vous pouvez utiliser l'API Google Pay™ pour récupérer les détails personnels de vos clients tels que leur adresse ou leur e-mail.

Une fois que vous avez suivi les directives de configuration de Google, vous êtes prêt pour l'intégration technique. Google propose un tutoriel clair et concis sur la manière d'implémenter Google Pay™ sur votre site web. L'intégration technique inclut les étapes suivantes :

1. Récupérer GooglePay™
2. Obtenir les réseaux de cartes de crédit disponibles
3. Se conformer à l'Authentification Forte du Client (SCA)
4. Afficher le bouton Google Pay™
5. Initialiser la feuille de paiement
6. Obtenir le token de paiement
7. Envoyer le token de paiement

1. Récupérer Google Pay™

Utilisez le JavaScript Client SDK pour récupérer le moyen de paiement Google Pay™ via l’appel API payment product(s). Cela vous fournira les données nécessaires pour les étapes suivantes, comme les réseaux pris en charge.

Utilisez l’exemple de code suivant pour effectuer l’appel :  

// session is an instance of the Session object, the SDK's main entry point. Note that the session has to be initialized before using it.
const googlePayProduct = await session.getPaymentProduct(320, paymentDetails).catch(() => null);
if (!googlePayProduct) {
    // Google Pay™ is not available, offer your customer another payment option to complete the payment
}
// Google Pay™ is available, show the Google Pay™ button

2. Préparer les données de la requête

Vous devez spécifier le réseau de carte de crédit autorisé pour la transaction Google Pay™ en cours. L’appel GetPaymentProduct (à la fois en client-to-server et en server-to-server) renvoie les réseaux disponibles. Les réseaux sont disponibles dans le champ de réponse paymentProduct320SpecificData. L’API Google Pay™ accepte directement les valeurs renvoyées.

Comme nous déchiffrons pour vous le jeton de paiement Google Pay™, vous devez définir une valeur spécifique pour le champ gateway dans la requête de tokenisation. Cette valeur est également disponible dans paymentProduct320SpecificData.

• merchantID : l’identifiant merchantID que vous recevez de Google après votre inscription dans la Google Pay™ Business Console.
• merchantName : le nom affiché dans la fenêtre de paiement. Ce champ est obligatoire si vous êtes basé dans l’Espace économique européen (EEE) afin de répondre aux exigences d’authentification forte (SCA). Encodez merchantName en UTF‑8 conformément aux spécifications de Google.
• gateway : utilisez la valeur renvoyée dans la réponse produit (voir les extraits de code ci‑dessous).
• gatewayMerchantId : votre identifiant marchand (PSPID) sur notre plateforme.

3. Se conformer à l’authentification forte (SCA)

Si votre acquéreur est situé dans l’Espace économique européen (EEE), vous devez transmettre à Google les informations de pays/région de la banque acquéreuse dans TransactionInfo.countryCode. Cela garantira le respect des exigences SCA. Google Pay™ renverra des données de transaction adaptées au pays/région de votre acquéreur.

Vous trouverez plus d’informations sur la conformité à l’authentification forte pour Google Pay™ dans la documentation de l’API Google Pay™ et dans notre guide dédié.

4. Rendre le bouton Google Pay™

Si Google Pay™ est disponible, ajoutez le bouton Google Pay™ sur votre page de paiement. Assurez-vous de suivre les directives de Google concernant l'affichage du bouton Google Pay™ et la politique de marque de Google.

Utilisez l'exemple de code suivant pour l'ajouter :

Ajouter le bouton Google Pay™

function addGooglePayButton() {
    const paymentsClient = getGooglePaymentsClient();
    const button =
        paymentsClient.createButton({
            onClick: onGooglePaymentButtonClicked
        });
    document.getElementById('container').appendChild(button);
}

5. Initialiser la feuille de paiement

Répondez au client en utilisant le bouton Google Pay™ en créant une session de paiement Google Pay™ pour le paiement :

Afficher la feuille de paiement Google Pay™

function onGooglePaymentButtonClicked() {
    const paymentDataRequest = getGooglePaymentDataRequest();
    paymentDataRequest.transactionInfo = getGoogleTransactionInfo();
    
    const paymentsClient = getGooglePaymentsClient();
    paymentsClient.loadPaymentData(paymentDataRequest).then(function(paymentData) {
        // gérer la réponse
        processPayment(paymentData);
    }).catch(function(err) {
        // afficher l'erreur dans la console du développeur pour débogage
        console.error(err);
    });
}

6. Obtenir le token de paiement

Pour traiter le paiement réel, vous devez demander le token de paiement à Google. Pour ce faire, utilisez l'exemple de code suivant :

    Obtenir le token de paiement Google Pay™

function processPayment(paymentData) {
    var paymentToken = paymentData.paymentMethodData.tokenizationData.token;
    @todo traiter le paymentToken comme décrit à l'étape suivante
}

7. Envoyer le token de paiement

Dans l'appel API de création de paiement, vous pouvez fournir des tokens de paiement de deux manières différentes :

1. Envoyez le token dans la propriété mobilePaymentMethodSpecificInput.encryptedPaymentData. Assurez-vous également d'envoyer mobilePaymentMethodSpecificInput.paymentProductId
   

   
   {
      "mobilePaymentMethodSpecificInput":{
         "encryptedPaymentData":"{\"signature\":\"MEUCIQCcSASjWu3ax9jQ8qX/+rsNLZ95uiyxamXiKnHlJi8A1QIgZj ...",
         "paymentProductId":"320"
      }
   }
   

2. Spécifiez le token comme valeur de paiement dans encryptedCustomerInput. Cette entrée est une liste chiffrée de paires clé-valeur, contenant généralement des données saisies par l'utilisateur, qui est compilée en fonction du champ de saisie réel. Les détails de paiement chiffrés du client :
   • sont à nouveau chiffrés
   • envoyés à votre serveur
   • enfin à notre serveur
     
     Vous devez utiliser le SDK Android côté client pour créer la valeur CustomerInput chiffrée. L'fieldId du champ de données de paiement chiffrées est renvoyé lorsque Google Pay™ reçoit des moyens de paiement via l'API. Bien que ce champ soit renvoyé comme un champ de saisie, vous ne devez pas fournir ce champ aux utilisateurs.

     
     // Cet exemple suppose que le SDK est correctement initialisé
     var paymentRequest = session.getPaymentRequest();
     paymentRequest.setValue("encryptedPaymentData", "{\"signature\":\"MEUCIG/WtsJnBf6yLsvnD2LOGaVMCO8E93QizIE0foMscVujAi...\"}")
     
     var encryptor = session.getEncryptor();
     
     encryptor.encrypt(paymentRequest).then(function(encryptedString) {
         // Envoyez le encryptedString à votre backend. Cette chaîne exacte est la valeur attendue pour le
         // encryptedCustomerInput dans Server-to-server CreatePaymentAPI
     }, function(errors) {
         // Informez le consommateur qu'un problème s'est produit
     });
     

Une fois que vous avez reçu le token, envoyez la requête de paiement à notre plateforme. Ajoutez les propriétés suivantes à une requête CreatePayment standard :

Trouvez des informations détaillées sur cet objet et ses propriétés dans notre API CreatePayment.

Une requête typique ressemble à ceci :

    Request with 3-D Secure properties using encryptedPaymentData

{
  "mobilePaymentMethodSpecificInput": {
    "paymentProductId": "320",
    "requiresApproval": true,
    "encryptedPaymentData": "{\"signature\":\"MEUCIG/WtsJnBf6yLsvnD2LOGaVMCO8E93QizIE0foMscVujAi..."
  },
    "paymentProduct320SpecificInput": {
        "threeDSecure": {
          "challengeIndicator": "no-preference",
          "challengeCanvasSize": "600x400",
          "skipAuthentication": false,
          "redirectionData": {
            "returnUrl": "https://hostname.myownwebsite.url",
            "variant": "100"
        }
    }
  },
  "order": {
    "amountOfMoney": {
      "currencyCode": "EUR",
      "amount": 2300
    },
    "customer": {
      "billingAddress": {
        "countryCode": "BE"
      },
      "device": {
        "acceptHeader": "texthtml,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "browserData": {
          "colorDepth": 24,
          "javaEnabled": false,
          "screenHeight": "1200",
          "screenWidth": "1920"
        },
        "ipAddress": "123.123.123.123",
        "locale": "en-US",
        "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Safari/605.1.15",
        "timezoneOffsetUtcMinutes": "420"
      },
      "locale": "en_US",
      "merchantCustomerId": "your id="" of="" the="" consumer="""
    }
  }
}
    

    Request with 3-D Secure properties using encryptedCustomerInput

{
  "mobilePaymentMethodSpecificInput": {
    "paymentProductId": "320",
    "requiresApproval": true
  },
    "paymentProduct320SpecificInput": {
        "threeDSecure": {
          "challengeIndicator": "no-preference",
          "challengeCanvasSize": "600x400",
          "skipAuthentication": false,
          "redirectionData": {
            "returnUrl": "https://hostname.myownwebsite.url",
            "variant": "100"
        }
    }
  },
  "order": {
    "amountOfMoney": {
      "currencyCode": "EUR",
      "amount": 2300
    },
    "customer": {
      "billingAddress": {
        "countryCode": "BE"
      },
      "device": {
        "acceptHeader": "texthtml,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "browserData": {
          "colorDepth": 24,
          "javaEnabled": false,
          "javaScriptEnabled": true,
          "screenHeight": "800",
          "screenWidth": "360"
        },
        "ipAddress": "123.123.123.123",
        "locale": "en-US",
        "userAgent": "Mozilla/5.0 (Linux; Android 10; SM-G980F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Mobile Safari/537.36",
        "timezoneOffsetUtcMinutes": "420"
      },
      "locale": "en_US",
      "merchantCustomerId": "your id="" of="" the="" consumer="""
    },
    "encryptedCustomerInput" : "encrypted string=""" 
  }
}

    Request without 3-D Secure properties using encryptedpaymentdata
    
    {
    "order" : {
        "amountOfMoney" : {
            "currencyCode" : "EUR",
            "amount" : 2300
        },
        "customer" : {
           "merchantCustomerId": "
  
   ",
           "billingAddress" : { 
                "countryCode" : "NL"
            }
        }
    },
    "mobilePaymentMethodSpecificInput" : { 
        "paymentProductId" : 320, 
        "encryptedPaymentData": "{\"signature\":\"MEUCIQCcSASjWu3ax9jQ8qX/+rsNLZ95uiyxamXiKnHlJi8A1QIgZj ..."
    } 
}

  

    Request without 3-D Secure properties using encryptedcustomerinput

    
    {
    "order" : {
        "amountOfMoney" : {
            "currencyCode" : "EUR",
            "amount" : 2300
        },
        "customer" : {
           "merchantCustomerId": "your id="" of="" the="" consumer=""",
           "billingAddress" : { 
                "countryCode" : "NL"
            }
        }
    },
    "encryptedCustomerInput" : "encrypted string=""" 
}

Google Pay™ dans l'application

Nous proposons également Google Pay™ pour les applications Android natives. Notre client SDK Android vous aide à intégrer Google Pay™ dans votre application tandis que nous déchiffrons pour vous les informations de paiement sensibles.

Une fois que vous avez suivi les directives d'installation de Google, vous êtes prêt à commencer l'intégration technique avec nous. Google offre un tutoriel très clair et concis sur la façon d'implémenter Google Pay™ sur votre site Web. L'intégration technique inclut les étapes suivantes :

• Récupérer Google Pay™
• Se conformer à l'authentification forte du client (SCA)
• Afficher le bouton Google Pay™
• Obtenir le token de paiement
• Envoyer le token de paiement

1. Récupérer Google Pay™

Google Pay™ n’est pas toujours disponible sur tous les appareils. Le client Android SDK vous permet de masquer facilement Google Pay™ dans ce cas. Notre plateforme renverra alors null. Utilisez l’exemple de code suivant pour effectuer cet appel :

// The paymentContext is an instance of the PaymentContext class holing the order payment data, such as amount and currency
val googlePayProduct = session.getPaymentProduct(320, paymentContext)
if (googlePayProduct != null) {
    // Google Pay™ is available, render the Google Pay™ button.
} else {
    // Google Pay™ is NOT available.
}

2. Se conformer à l’authentification forte (SCA)

Si votre acquéreur est situé dans l’Espace économique européen (EEE), vous devez transmettre à Google les informations de pays/région de la banque acquéreuse dans TransactionInfo.countryCode. Cela garantira le respect des exigences SCA. Google Pay™ renverra des données de transaction adaptées au pays/région de votre acquéreur.

L’appel API payment product depuis le Client SDK ou en Server-to-Server renvoie le champ acquirerCountry, que vous devez envoyer à Google. 

private JSONObject getGooglePayPaymentRequestData(PaymentContext paymentContext, PaymentProduct googlePayProduct) {
    val googlePayData = googlePayProduct.paymentProduct320SpecificData
    val cardPaymentMethod = JSONObject().apply {
        put("type", "CARD")
        put("parameters", JSONObject().apply {
            put("allowedAuthMethods", JSONArray(listOf("PAN_ONLY", "CRYPTOGRAM_3DS")))
            put("allowedCardNetworks", JSONArray(googlePayData.networks))
            put("billingAddressRequired", false)
        })
        put("tokenizationSpecification", JSONObject().apply {
            put("type", "PAYMENT_GATEWAY")
            put("parameters", JSONObject().apply {
                put("gateway", googlePayData.gateway)
                put("gatewayMerchantId", merchantId)
            })
        })
    }

val transactionInfo = JSONObject().apply {
put("totalPrice", price.toString())
put("totalPriceStatus", "FINAL")
put("currencyCode", currencyCode)
// use the acquirer country code or the country code from your current context
put("countryCode", "BE")
}

    val paymentRequest = JSONObject() {
        put("apiVersion", 2)
        put("apiVersionMinor", 0)
    }

    paymentRequest.put("allowedPaymentMethods", JSONArray().put(cardPaymentMethod))
    paymentRequest.put("transactionInfo", transactionInfo)
    paymentRequest.put("merchantInfo", JSONObject().apply {
        put("merchantId", googleMerchantId)
        put("merchantName", googleMerchantName)
    })
    return paymentRequest;
}

Vous trouverez plus d’informations sur la conformité à l’authentification forte pour Google Pay™ dans la documentation de l’API Google Pay™ et dans notre guide dédié.

3. Afficher le bouton Google Pay™

Une fois la requête de paiement préparée, affichez le bouton Google Pay™ dans votre application. Veillez à respecter les directives de Google sur l’affichage du bouton Google Pay™ et la politique de marque de Google.

val walletOptions = Wallet.WalletOptions.Builder()
    .setEnvironment(WalletConstants.ENVIRONMENT_PRODUCTION)
    .build()
val client = Wallet.getPaymentsClient(activity, walletOptions)
val requestData = getGooglePayPaymentRequestData(paymentContext, googlePayProduct)
val isReadyToPayRequest = IsReadyToPayRequest.fromJson(requestData.toString())
// First, determine whether Google Pay™ is ready
val isReadyToPayTask = client.isReadyToPay(isReadyToPayRequest)
isReadyToPayTask.addOnCompleteListener { completedTask ->
    try {
        val isAvailable = completedTask.getResult(ApiException::class.java)
        if (isAvailable) {
             val task = client.loadPaymentData(paymentRequest)
             // note that Google Pay requires an activity flow 
             AutoResolveHelper.resolveTask(
                client.loadPaymentData(PaymentDataRequest.fromJson(requestData.toString())),
                requireActivity(),
                GOOGLE_PAY_REQUEST_CODE // Your activity code. Check onActivityResult() method below.
            )
        }
    } catch (_: ApiException) {
        // Google pay is not available
    }
}

4. Récupérer le jeton de paiement

Une fois le processus Google Pay réussi, vous devez récupérer le jeton de paiement. Pour ce faire, utilisez l’extrait de code suivant :

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    when (requestCode) {
        GOOGLE_PAY_REQUEST_CODE -> {
            when (resultCode) {
                Activity.RESULT_OK ->
                    data?.let { intent ->
                        PaymentData.getFromIntent(intent)?.let(::handleGooglePaySuccess)
                    }

                Activity.RESULT_CANCELED -> {
                    dismiss()
                }

                AutoResolveHelper.RESULT_ERROR -> {
                    AutoResolveHelper.getStatusFromIntent(data)?.let { status ->
                        // display the error message
                    }
                    dismiss()
            }
        }
        }
    }
}

private fun handleGooglePaySuccess(paymentData: PaymentData) {
    val paymentDataJSONString = paymentData.toJson()
    try {
        // Token will be null if PaymentDataRequest was not constructed using fromJson(String).
        val unformattedGooglePayToken = JSONObject(paymentDataJSONString)
            .getJSONObject("paymentMethodData")
            .getJSONObject("tokenizationData").getString("token")

        // Token needs to be formatted when using it to create a payment
        // with mobilePaymentMethodSpecificInput.encryptedPaymentData
        // Send this to your server to be processed. Check step 5 for more details.
        val formattedGooglePayToken = JSONObject.quote(unformattedGooglePayToken)
    } catch (exception: JSONException) {
        // display the error message
    }
}

5. Envoyer le jeton de paiement

Dans l’appel API Create payment, vous pouvez fournir les jetons de paiement de deux manières différentes :

1. Vous pouvez traiter le jeton de paiement brut reçu à l’étape précédente. Voici un extrait de l’objet de requête Create Payment :
   

   {
      // ...
      "mobilePaymentMethodSpecificInput":{
         "encryptedPaymentData": formattedGooglePayToken,
         "paymentProductId":"320"
      }
      // ...
   }
   

2. Vous pouvez utiliser le Client SDK pour chiffrer le jeton et l’envoyer comme valeur de paiement dans le champ encryptedCustomerInput de la requête Create Payment. Cet input est une liste chiffrée de paires clé‑valeur, contenant généralement les données saisies par l’utilisateur, compilée à partir des champs de saisie réels. Les données de paiement chiffrées du client :
   
   • sont chiffrées à nouveau
   • sont envoyées à votre serveur
   • sont utilisées dans le Server SDK pour créer un paiement
   
   Voici le code qui explique comment les chiffrer à l’aide du SDK Android et du code décrit précédemment :
   

       val paymentRequest = PaymentRequest()
       paymentRequest.paymentProduct = googlePayProduct
       paymentRequest.setValue("encryptedPaymentData", formattedGooglePayToken)
       val encryptedString = session.preparePaymentRequest(paymentRequest)

   Une fois envoyée à votre serveur, utilisez cette valeur pour construire l’objet de requête Create Payment :

   {
      // ...
      "encryptedCustomerInput": encryptedString,
      // ...
   }

   Vous trouverez des informations détaillées sur cet objet et ses propriétés dans notre CreatePaymentAPI.

Process flows

1. Vos clients finalisent une commande dans votre boutique / application et sélectionnent Google Pay™.
2. Votre serveur envoie un appel API spécifique à Google pour afficher une liste de méthodes de paiement prises en charge dans le navigateur / l'application.
3. Vos clients sélectionnent une méthode de paiement.
4. Votre serveur demande un token de paiement à Google.
5. Vous envoyez cette demande CreatePayment à notre plateforme, contenant le token de paiement dans la propriété mobilePaymentMethodSpecificInput.encryptedPaymentData
   5'(Optionnel pour les paiements passant par votre propre page de paiement). Si vos clients utilisent une carte non tokenisée par le réseau, vous redirigez les clients vers leur banque émettrice pour l'authentification 3-D Secure.
   5''(Optionnel pour les paiements passant par votre propre page de paiement). Vos clients effectuent la vérification 3-D Secure. Notre système reçoit le résultat de l'émetteur. Selon le résultat, deux scénarios sont possibles :
   a) Si l'identification a réussi, le flux continue à l'étape 6.
   b) Si l'identification a échoué, nous redirigeons vos clients vers votre returnUrl, mettant fin au flux. Vous pouvez demander le résultat de la transaction comme décrit à l'étape 8.
6. Google Pay™ traite la transaction financière réelle. Nous recevons le résultat de la transaction.
7. Nous redirigeons votre client vers votre application / returnUrl
8. Vous demandez le résultat de la transaction à notre plateforme via GetPaymentDetails ou recevez le résultat via webhooks.
9. Si la transaction a réussi, vous pouvez livrer les biens / services.

Testing

Consultez nos Test cases pour des données de test et des instructions détaillées.

Additional information

Google Pay et Card On File

Card On File (COF) permet de stocker les détails de la carte d’un client pour des paiements futurs, ce qui est également possible pour Google Pay.
Le cadre COF définit l'utilisation équitable des données de carte stockées, vous fournissant des instructions spécifiques. Nous expliquons cela dans la section cas d'utilisation dédiée et fournissons pour chacun des exemples JSON/API endpoints. Google Pay ne supporte que les cas d'utilisation A et E, et comme il y a des différences, nous les documentons ici directement.

Exemple A - CIT premier et récurrent

{
    "mobilePaymentMethodSpecificInput": {
        "paymentProduct320SpecificInput": {
            "tokenize": true,
            "recurring": {
                "recurringPaymentSequenceIndicator": "first"
            },
            "threeDSecure": {
                "challengeIndicator": "challenge-required",
                "skipAuthentication": false,
                "exemptionRequest": "none"
            }
        }
    },
    "hostedCheckoutSpecificInput": {
        "isRecurring": true
    },
    "order": {
        "amountOfMoney": {
            "amount": 10,
            "currencyCode": "EUR"
        }
    }
}

{
    "mobilePaymentMethodSpecificInput": {
        "paymentProductId": 320,
        "encryptedPaymentData": {\"signature\":\"MEUCIQCcSASjWu3ax9jQ8qX/+rsNLZ95uiyxamXiKnHlJi8A1QIgZj ...",
        "requiresApproval": true,
        "paymentProduct320SpecificInput": {
            "threeDSecure":{
                "challengeIndicator": "challenge-required",
                "redirectionData": {
                    "returnUrl":"https://yourRedirectionUrl.com"
                }
            },
            "isRecurring": true,
            "tokenize": true,
            "recurring": {
                "recurringPaymentSequenceIndicator": "first"
            }
        }
    },
    "order": {
        "amountOfMoney": {
            "currencyCode": "EUR",
            "amount": 10
        },
        "customer":{
            "device":{
                "acceptHeader": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
                "browserData":{
                    "colorDepth": 99,
                    "javaEnabled": true,
                    "javaScriptEnabled": true,
                    "screenHeight":" 768",
                    "screenWidth": "1024"
                },
                "ipAddress": "123.123.123.123",
                "locale": "en_GB",
                "userAgent": "Mozilla/5.0(WindowsNT10.0;Win64;x64)AppleWebKit/537.36(KHTML,likeGecko)Chrome/75.0.3770.142Safari/537.36",
                "timezoneOffsetUtcMinutes": "-180"
            }
        }
    }
}

Exemple E - Paiements programmés MIT

SubsequentPayment

{
  "subsequentCardPaymentMethodSpecificInput": {
    "subsequentType": "recurring"
  },
  "order": {
    "amountOfMoney": {
      "amount": 100,
      "currencyCode": "EUR"
    }
  }
}