# Google Pay Comment accepter des paiements avec Google Pay. > Depuis septembre 2019, la législation relative à l’*authentification forte du client* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) (SCA) contraint les entreprises européennes à soumettre leurs clients à une authentification supplémentaire pour les paiements effectués en ligne. Google Pay étant déjà capable de gérer les tunnels de paiement disposant d’une authentification intégrée (biométrique ou par mot de passe), il est pleinement compatible avec la SCA. > > [En savoir plus sur la SCA et son impact sur votre activité](https://docs.stripe.com/strong-customer-authentication.md). Pour plus d’informations sur les frais de transaction du moyen de paiement, reportez-vous aux [informations tarifaires](https://stripe.com/pricing/local-payment-methods). Google Pay permet à vos clients d’effectuer des paiements dans votre application ou sur votre site Web à l’aide d’une carte de crédit ou de débit enregistrée sur leur compte Google, y compris les cartes enregistrées sur Google Play, YouTube, Chrome, ou un appareil Android. Utilisez l’API Google Pay pour accéder à une carte de crédit ou de débit enregistrée sur le compte Google de votre client. Google Pay est pleinement compatible avec les produits et fonctionnalités de Stripe (p. ex., les paiements récurrents), ce qui vous permet de remplacer les moyens de paiement traditionnels par Google Pay chaque fois que cela est possible. Utilisez Google Pay pour l’achat de marchandises, pour des *abonnements* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis), pour des dons, etc. > #### Conditions de Google Pay > > En intégrant Google Pay, vous acceptez les [Conditions d’utilisation](https://payments.developers.google.com/terms/sellertos) de Google. #### Propriétés des moyens de paiement - **Localisation des clients** Dans le monde entier, sauf en Inde - **Devise de présentation** Voir [Devises de présentation prises en charge](https://docs.stripe.com/currencies.md#presentment-currencies) - **Confirmation du paiement** Initié par le client - **Catégorie de moyens de paiement** Portefeuille - **Paiements récurrents** Oui - **Délai de virement** Les délais de virement standard s’appliquent - **Prise en charge de Connect** Oui - **Prise en charge des litiges** [Oui](https://docs.stripe.com/google-pay.md#disputed-payments) - **Prise en charge des captures manuelles** Oui - **Remboursements complets/partiels** [Oui/oui](https://docs.stripe.com/google-pay.md#refunds) #### Pays de l'entreprise Les comptes Stripe du monde entier, à l’exception de l’Inde, peuvent accepter les paiements Google Pay avec règlement dans la devise locale. #### Prise en charge des produits - Connect - Checkout - Payment Links - Elements - Subscriptions - Invoicing ## Utilisation de Stripe et Google Pay avec le système de facturation Google Play Ce guide explique comment configurer votre application pour qu’elle accepte Google Pay pour des biens physiques, des services et d’autres éléments éligibles. Stripe traite ces paiements, et vous ne payez que les [frais de traitement](https://stripe.com/pricing) de Stripe. Pour les produits, contenus et abonnements numériques vendus aux États-Unis ou dans l’Espace économique européen (EEE), votre application Android peut accepter des paiements directement in-app via un prestataire de paiement tiers tel que Stripe. Vous pouvez utiliser les interfaces utilisateur de paiement suivantes : - [Mobile Payment Element](https://docs.stripe.com/payments/mobile.md) pour accepter des paiements directement in-app - [Stripe Checkout](https://docs.stripe.com/mobile/digital-goods/checkout.md) pour rediriger vos clients vers une page de paiement hébergée par Stripe - [Payment Links](https://docs.stripe.com/mobile/digital-goods/payment-links.md) pour un nombre limité de produits et de tarifs Pour en savoir plus sur les achats qui doivent utiliser le système de facturation Google Play, consultez les [Conditions d’utilisation pour les développeurs](https://support.google.com/googleplay/android-developer/answer/10281818) de Google Play. # Android > This is a Android for when platform is android. View the full page at https://docs.stripe.com/google-pay?platform=android. ## Accepter un paiement Google Pay dans votre application Android `GooglePayLauncher`, inclus dans le SDK Android de Stripe, est le moyen le plus rapide et le plus simple pour commencer à accepter Google Pay dans vos applications Android. ## Conditions préalables Pour prendre en charge Google Pay dans Android, vous avez besoin des éléments suivants : - Une valeur `minSdkVersion` supérieure ou égale à `19`. - Une valeur `compileSdkVersion` supérieure ou égale à `28`. En outre, si vous souhaitez effectuer un test avec votre propre appareil, vous devez [ajouter un moyen de paiement à votre compte Google](https://support.google.com/wallet/answer/12058983?visit_id=637947092743186187-653786796&rd=1) . ## Configurer votre intégration Dans ce guide, nous partons du principe que vous utilisez la dernière version du SDK Android de Stripe. #### Groovy ```groovy dependencies { implementation 'com.stripe:stripe-android:23.2.0' } ``` Pour utiliser Google Pay, commencez par activer l’API Google Pay en ajoutant les informations suivantes au libellé `` de votre **AndroidManifest.xml** : ```xml ... ``` Pour en savoir plus, consultez cette page indiquant comment [configurer l’API Google Pay](https://developers.google.com/pay/api/android/guides/setup) pour Android. ## Créer un PaymentIntent ### Côté serveur Créez un `PaymentIntent` sur votre serveur avec un [montant](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) et une [devise](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Déterminez toujours le montant à facturer côté serveur, dans un environnement de confiance, plutôt que côté client. Cela empêche des utilisateurs malveillants de choisir eux-mêmes leurs prix. #### curl ```bash curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -d "amount"=1099 \ -d "currency"="usd" ``` ### Côté client Un PaymentIntent inclut une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Vous pouvez utiliser la clé secrète du client dans votre application Android pour finaliser le processus de paiement en toute sécurité, au lieu de transmettre l’intégralité de l’objet PaymentIntent. Dans votre application, demandez un PaymentIntent à votre serveur et stockez sa clé secrète du client. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // ... startCheckout() } private fun startCheckout() { // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret // Click View full sample to see a complete implementation } } ``` ## Ajouter le bouton Google Pay Ajoutez le bouton Google Pay à votre application en suivant [le tutoriel de Google](https://developers.google.com/pay/api/android/guides/tutorial#add-button). Cela permet de s’assurer que vous utilisez les bonnes ressources. ## Instancier GooglePayLauncher Créez ensuite une instance de [GooglePayLauncher](https://github.com/stripe/stripe-android/blob/master/payments-core/src/main/java/com/stripe/android/googlepaylauncher/GooglePayLauncher.kt) dans votre `Activity` ou votre `Fragment`. Cette opération doit être réalisée dans `Activity#onCreate()`. `GooglePayLauncher.Config` expose les propriétés obligatoires et facultatives qui configurent `GooglePayLauncher`. Consultez `GooglePayLauncher.Config` pour plus d’informations sur les options de configuration. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // fetch client_secret from backend private lateinit var clientSecret: String private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.checkout_activity) PaymentConfiguration.init(this, PUBLISHABLE_KEY) googlePayButton = /* TODO: Initialize button by following Google's guide. */ val googlePayLauncher = GooglePayLauncher( activity = this, config = GooglePayLauncher.Config( environment = GooglePayEnvironment.Test, merchantCountryCode = "US", merchantName = "Widget Store" ), readyCallback = ::onGooglePayReady, resultCallback = ::onGooglePayResult ) googlePayButton.setOnClickListener { // launch `GooglePayLauncher` to confirm a Payment Intent googlePayLauncher.presentForPaymentIntent(clientSecret) } } private fun onGooglePayReady(isReady: Boolean) { // implemented below } private fun onGooglePayResult(result: GooglePayLauncher.Result) { // implemented below } } ``` Après l’instanciation de `GooglePayLauncher`, l’instance `GooglePayLauncher.ReadyCallback` est appelée avec un indicateur indiquant si Google Pay est disponible et prêt à l’emploi. Cet indicateur peut être utilisé pour mettre à jour votre interface utilisateur afin de signaler à la clientèle que Google Pay est disponible. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // continued from above private lateinit var googlePayButton: PayButton private fun onGooglePayReady(isReady: Boolean) { googlePayButton.isEnabled = isReady } } ``` ## Lancer GooglePayLauncher Une fois que Google Pay est disponible et que votre application a obtenu une clé secrète du client `PaymentIntent` ou `SetupIntent`, lancez `GooglePayLauncher` à l’aide de la méthode appropriée. Lors de la confirmation d’un `PaymentIntent`, utilisez `GooglePayLauncher#presentForPaymentIntent(clientSecret)`. Lors de la confirmation d’un `SetupIntent`, utilisez `GooglePayLauncher#presentForSetupIntent(clientSecret)`. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { // fetch client_secret from backend private lateinit var clientSecret: String private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // instantiate `googlePayLauncher` googlePayButton.setOnClickListener { // launch `GooglePayLauncher` to confirm a Payment Intent googlePayLauncher.presentForPaymentIntent(clientSecret) } } } ``` ## Gérer le résultat Enfin, implémentez `GooglePayLauncher.ResultCallback` pour gérer le résultat de l’opération `GooglePayLauncher`. Ce résultat peut être `GooglePayLauncher.Result.Completed`, `GooglePayLauncher.Result.Canceled` ou `GooglePayLauncher.Result.Failed`. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { // continued from above private fun onGooglePayResult(result: GooglePayLauncher.Result) { when (result) { GooglePayLauncher.Result.Completed -> { // Payment succeeded, show a receipt view } GooglePayLauncher.Result.Canceled -> { // User canceled the operation } is GooglePayLauncher.Result.Failed -> { // Operation failed; inspect `result.error` for the exception } } } } ``` ## Passer en mode production avec Google Pay Suivez les [instructions de Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) pour demander un accès en production pour votre application. Choisissez le type d’intégration **Gateway**, et fournissez des captures d’écran de votre application pour vérification. Une fois votre application approuvée, testez votre intégration en mode production en définissant l’environnement sur `GooglePayEnvironment.Production` et en lançant Google Pay à partir d’une version publiée de votre application. N’oubliez pas d’utiliser vos [clés API](https://docs.stripe.com/keys.md) en *mode production* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Vous pouvez utiliser un `PaymentIntent` avec [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) pour traiter une transaction sans capturer le paiement. ### Tester Google Pay Google vous permet d’effectuer des paiements de test via leur [suite de carte bancaire de test](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). La suite de tests prend en charge l’utilisation de [cartes bancaires de test](https://docs.stripe.com/testing.md) de Stripe. Vous devez tester Google Pay à l’aide d’un appareil Android physique plutôt que d’un appareil simulé, dans un pays où Google Pay est pris en charge. Connectez-vous à un compte Google sur votre appareil de test avec une carte réelle enregistrée dans Google Wallet. ## Créer un PaymentMethod Si la confirmation des paiements a lieu sur votre serveur, vous pouvez utiliser `GooglePayPaymentMethodLauncher` pour ne collecter qu’un objet `PaymentMethod`, sans confirmer le paiement. #### Kotlin ```kotlin import com.google.android.gms.wallet.button.PayButton class CheckoutActivity : AppCompatActivity() { private lateinit var googlePayButton: PayButton override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.checkout_activity) PaymentConfiguration.init(this, PUBLISHABLE_KEY) googlePayButton = /* TODO: Initialize button by following Google's guide. */ val googlePayLauncher = GooglePayPaymentMethodLauncher( activity = this, config = GooglePayPaymentMethodLauncher.Config( environment = GooglePayEnvironment.Test, merchantCountryCode = "FR", merchantName = "Widget Store" ), readyCallback = ::onGooglePayReady, resultCallback = ::onGooglePayResult ) googlePayButton.setOnClickListener { googlePayLauncher.present( currencyCode = "EUR", amount = 2500 ) } } private fun onGooglePayReady(isReady: Boolean) { googlePayButton.isEnabled = isReady } private fun onGooglePayResult( result: GooglePayPaymentMethodLauncher.Result ) { when (result) { is GooglePayPaymentMethodLauncher.Result.Completed -> { // Payment details successfully captured. // Send the paymentMethodId to your server to finalize payment. val paymentMethodId = result.paymentMethod.id } GooglePayPaymentMethodLauncher.Result.Canceled -> { // User canceled the operation } is GooglePayPaymentMethodLauncher.Result.Failed -> { // Operation failed; inspect `result.error` for the exception } } } } ``` # React Native > This is a React Native for when platform is react-native. View the full page at https://docs.stripe.com/google-pay?platform=react-native. Le SDK React Native de Stripe est la solution la plus rapide et la plus simple pour commencer à accepter Google Pay dans vos applications React Native. Le composant [PlatformPayButton](https://stripe.dev/stripe-react-native/api-reference/index.html#PlatformPayButton) encapsule l’interface utilisateur requise par Google, et vous pouvez utiliser les méthodes `confirmPlatformPayPayment` et `createPlatformPayPaymentMethod` pour collecter ou créer facilement des paiements dans votre application avec une configuration minimale. > Si vous utilisez React Native et Expo, Expo Go ne prend pas en charge Google Pay. Pour utiliser Google Pay avec Expo, vous devez créer une [version de développement](https://docs.expo.dev/get-started/set-up-your-environment/?mode=development-build&platform=android). Si vous avez déjà un projet Expo Go, vous pouvez le [migrer vers une version de développement](https://docs.expo.dev/develop/development-builds/expo-go-to-dev-build/). ## Configurer Stripe [Côté serveur] [Côté client] ### Côté serveur Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur : #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Côté client Le [SDK React Native](https://github.com/stripe/stripe-react-native) est disponible en open source et fait l’objet d’une documentation complète. En interne, il utilise des SDK [Android](https://github.com/stripe/stripe-android) et [iOS natifs](https://github.com/stripe/stripe-ios). Pour installer le SDK React Native de Stripe, exécutez l’une des commandes suivantes dans le répertoire de votre projet (selon le gestionnaire de paquets que vous utilisez) : #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Ensuite, installez les autres dépendances nécessaires : - Pour iOS, accédez au directeur **ios** et exécutez `pod install` pour vous assurer que vous installez également les dépendances natives requises. - Pour Android, il n’y a plus de dépendances à installer. > Nous vous recommandons de suivre le [guide officiel de TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) pour ajouter la prise en charge de TypeScript. ### Initialisation de Stripe Pour initialiser Stripe dans votre application React Native, wrappez votre écran de paiement avec le composant `StripeProvider` ou utilisez la méthode d’initialisation `initStripe`. Seule la [clé publiable](https://docs.stripe.com/keys.md#obtain-api-keys) de l’API dans `publishableKey` est nécessaire. L’exemple suivant montre comment initialiser Stripe à l’aide du composant `StripeProvider`. ```jsx import { useState, useEffect } from 'react'; import { StripeProvider } from '@stripe/stripe-react-native'; function App() { const [publishableKey, setPublishableKey] = useState(''); const fetchPublishableKey = async () => { const key = await fetchKey(); // fetch key from your server here setPublishableKey(key); }; useEffect(() => { fetchPublishableKey(); }, []); return ( {/* Your app code here */} ); } ``` > Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) d’API lors de vos activités de test et de développement, et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application. ## Activer Google Pay Pour utiliser Google Pay, commencez par activer l’API Google Pay en ajoutant les informations suivantes au libellé `` de votre **AndroidManifest.xml** : ```xml ... ``` Pour en savoir plus, consultez cette page indiquant comment [configurer l’API Google Pay](https://developers.google.com/pay/api/android/guides/setup) pour Android. ## Créer un PaymentIntent [Côté serveur] Créez d’abord un `PaymentIntent` sur votre serveur, puis indiquez le montant à encaisser et la devise. Si votre intégration inclut déjà l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `card` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) pour votre `PaymentIntent` (il s’agit aussi du moyen de paiement par défaut) : ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=card" \ -d amount=1099 \ -d currency=usd ``` Un PaymentIntent contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Au lieu de transmettre la totalité de l’objet PaymentIntent, vous pouvez utiliser la clé secrète du client dans votre application React Native pour finaliser le processus de paiement en toute sécurité. Dans votre application, demandez un PaymentIntent auprès de votre serveur et sauvegardez sa clé secrète du client. ## Initialiser Google Pay [Côté client] Tout d’abord, vérifiez si l’appareil prend en charge Google Pay en appelant `isPlatformPaySupported`. ```javascript import { usePlatformPay } from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported } = usePlatformPay(); React.useEffect(() => { (async function () { if (!(await isPlatformPaySupported({ googlePay: {testEnv: true} }))) { Alert.alert('Google Pay is not supported.'); return; } })(); }, []); ... return ( ... ); } ``` ## Présenter le formulaire Google Pay [Côté client] Une fois que vous savez que Google Pay est disponible et que votre application a obtenu une clé secrète du client `PaymentIntent` ou `SetupIntent`, appelez `confirmPlatformPayPayment`. Lors de la confirmation d’un `SetupIntent`, utilisez plutôt `confirmPlatformPaySetupIntent`. ```javascript import {PlatformPayButton, usePlatformPay} from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported, confirmPlatformPayPayment, } = usePlatformPay(); React.useEffect(() => { ... // see above }, []); const fetchPaymentIntentClientSecret = async () => { // Fetch payment intent created on the server, see above const response = await fetch(`${API_URL}/create-payment-intent`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ currency: 'usd', }), }); const { clientSecret } = await response.json(); return clientSecret; }; const pay = async () => { const clientSecret = await fetchPaymentIntentClientSecret(); const { error, paymentIntent } = await confirmPlatformPayPayment( clientSecret, { googlePay: { testEnv: true, merchantName: 'My merchant name', merchantCountryCode: 'US', currencyCode: 'USD', billingAddressConfig: { format: PlatformPay.BillingAddressFormat.Full, isPhoneNumberRequired: true, isRequired: true, }, }, } ); if (error) { Alert.alert(error.code, error.message); // Update UI to prompt user to retry payment (and possibly another payment method) return; } Alert.alert('Success', 'The payment was confirmed successfully.'); console.log(JSON.stringify(paymentIntent, null, 2)); }; return ( ); } ``` ## Optional: Créer un objet PaymentMethod [Côté client] Si la confirmation des paiements a lieu sur votre serveur, vous pouvez utiliser Google Pay pour collecter uniquement un objet `PaymentMethod`, sans confirmer le paiement. Pour cet appel, utilisez la méthode `createPlatformPayPaymentMethod` : ```javascript import {PlatformPayButton, usePlatformPay} from '@stripe/stripe-react-native'; function PaymentScreen() { const { isPlatformPaySupported, createPlatformPayPaymentMethod, } = usePlatformPay(); React.useEffect(() => { ... // see above }, []); const createPaymentMethod = async () => { const { error, paymentMethod } = await createPlatformPayPaymentMethod({ googlePay: { amount: 12, currencyCode: 'USD', testEnv: true, merchantName: 'Test', merchantCountryCode: 'US', }, }); if (error) { Alert.alert(error.code, error.message); return; } else if (paymentMethod) { Alert.alert( 'Success', `The payment method was created successfully. paymentMethodId: ${paymentMethod.id}` ); } }; return ( ); } ``` ## Passer en mode production avec Google Pay Suivez les [instructions de Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) pour demander un accès en production pour votre application. Choisissez le type d’intégration **Gateway**, et fournissez des captures d’écran de votre application pour vérification. Une fois votre application approuvée, testez votre intégration en mode production en utilisant `testEnv: false` et en lançant Google Pay à partir d’une version publiée de votre application. N’oubliez pas d’utiliser vos [clés API](https://docs.stripe.com/keys.md) en *mode production* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Vous pouvez utiliser un `PaymentIntent` avec [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) pour traiter une transaction sans capturer le paiement. ### Tester Google Pay Google vous permet d’effectuer des paiements de test via leur [suite de carte bancaire de test](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). La suite de tests prend en charge l’utilisation de [cartes bancaires de test](https://docs.stripe.com/testing.md) de Stripe. Vous devez tester Google Pay à l’aide d’un appareil Android physique plutôt que d’un appareil simulé, dans un pays où Google Pay est pris en charge. Connectez-vous à un compte Google sur votre appareil de test avec une carte réelle enregistrée dans Google Wallet. # Web > This is a Web for when platform is web. View the full page at https://docs.stripe.com/google-pay?platform=web. ## Accepter Google Pay sur le Web Vous pouvez accepter les paiements Google Pay en ligne en utilisant [Checkout](https://docs.stripe.com/payments/checkout.md) ou les composants [Elements](https://docs.stripe.com/payments/elements.md), en activant Google Pay dans vos [paramètres de moyens de paiement](https://dashboard.stripe.com/settings/payment_methods). L’utilisation de Google Pay dans Checkout ne nécessite aucune mise en œuvre de code supplémentaire. Concernant les composants Elements, consultez les guides [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element.md) ou [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout) pour découvrir comment ajouter Google Pay à votre site. Pour accepter les paiements Google Pay sur le Web, vous devez effectuer la diffusion à partir d’une page Web HTTPS avec un certificat validé par le domaine TLS. ### Enregistrez votre domaine avec Google Pay Pour utiliser Google Pay, vous devez enregistrer tous vos domaines web qui affichent un bouton Google Pay. Cela inclut les domaines de premier niveau (par exemple, **stripe.com**) et les sous-domaines (par exemple, **shop.stripe.com**), en production et en test. > #### Sous-domaines > > `www` est un sous-domaine (par exemple, **www.stripe.com**) que vous devez également enregistrer. Register your domain on the [Payment methods domains page](https://dashboard.stripe.com/settings/payment_method_domains) in the Dashboard or use the API with your live secret key, as shown in the following example. Register your domain only once per account. ```curl curl https://api.stripe.com/v1/payment_method_domains \ -u "<>:" \ -d "domain_name=example.com" ``` Lorsque vous utilisez des [paiements directs](https://docs.stripe.com/connect/direct-charges.md) avec *Connect* (Connect is Stripe's solution for multi-party businesses, such as marketplace or software platforms, to route payments between sellers, customers, and other recipients), vous devez configurer le domaine pour chaque compte connecté à l’aide de l’API. Cette condition n’est pas requise pour les comptes connectés utilisant d’autres types de frais. Après avoir enregistré vos domaines, vous pouvez effectuer des paiements sur votre site à l’aide de vos clés API. ## Tester Google Pay Google vous permet d’effectuer des paiements de test par le biais de sa [suite des cartes de test](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). Vous pouvez utiliser les [cartes de test](https://docs.stripe.com/testing.md) de Stripe avec la suite de tests. Avant de pouvoir utiliser une carte de test Stripe, vous devez ajouter une vraie carte bancaire à votre wallet pour que Google Pay s’affiche. Si vous ne répondez pas aux exigences en matière d’appareil et d’intégration, Stripe ne rend pas Google Pay comme option de paiement. Pour résoudre les problèmes de rendu avec Google Pay, utilisez notre [page de test](https://docs.stripe.com/testing/wallets.md). ## Litiges Les utilisateurs doivent authentifier leurs paiements à l’aide de leurs comptes Google Pay, ce qui contribue à réduire le risque de fraude ou de paiements non reconnus. Cependant, les utilisateurs peuvent toujours contester des transactions une fois le paiement finalisé. Vous pouvez soumettre des preuves pour contester directement un litige. La procédure de litige est la même que celle prévue pour les paiements par carte bancaire. Découvrez comment [gérer les litiges](https://docs.stripe.com/disputes/responding.md). ### Transfert de responsabilité pour les paiements Google Pay Google Pay prendre en charge le [transfert de responsabilité](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#disputed-payments) à l’échelle mondiale. Cela est valable automatiquement pour les utilisateurs de produits hébergés par Stripe et utilisant Stripe.js. Pour les transactions Visa effectuées en dehors d’un produit hébergé par Stripe, vous devez activer le transfert de responsabilité dans la console Google Pay & Wallet. Pour ce faire, accédez à votre console Google Pay & Wallet**, sélectionnez **API Google Pay** dans la barre de navigation située à gauche, puis activez la **\_protection contre la fraude pour les tokens de périphérique Visa** pour bénéficier de la protection contre les risques liés au transfert de responsabilité. Il existe trois cas d’usage des transactions Google Pay : 1. Si l’utilisateur ajoute une carte à l’application Google Pay à l’aide de son appareil mobile, cette carte est enregistrée en tant que numéro de compte principal de l’appareil (DPAN) et le transfert de responsabilité est pris en charge par défaut. 1. Si l’utilisateur ajoute une carte à Chrome ou une propriété Google (par exemple, YouTube ou Play), elle est enregistrée en tant que numéro de compte principal de financement (FPAN). Lorsque vous utilisez [3D Secure](https://docs.stripe.com/payments/3d-secure.md), nous prenons en charge le transfert de responsabilité pour tous les principaux réseaux, y compris Visa. Vous pouvez personnaliser les [règles Radar deStripe](https://docs.stripe.com/radar/rules.md#request-3d-secure) pour demander l’activation de 3D Secure. 1. Si l’utilisateur sélectionne Google Pay comme moyen de paiement sur un site d’e-commerce ou dans une application, les cartes sont enregistrées en tant que tokens d’e-commerce qui représentent les cartes enregistrées. Ni le transfert de responsabilité ni 3D Secure ne sont actuellement pris en charge pour les tokens d’e-commerce. Pour les utilisateurs de Sigma , la table `charges` contient un champ `card_token_type` qui indique le type de transaction Google Pay. Une transaction FPAN définit le `card_token_type` sur `fpan`. Les transactions DPAN et de token d’e-commerce définissent le `card_token_type` sur `dpan_or_ecommerce_token`. ## Remboursements Vous pouvez rembourser partiellement ou intégralement tout paiement Google Pay réussi. Le processus de remboursement est le même que pour les paiements par carte bancaire. Consultez la page [Rembourser et annuler des paiements](https://docs.stripe.com/refunds.md) pour en savoir plus sur la marche à suivre et la gestion des remboursements.