# Google Pay Obtén más información sobre cómo aceptar pagos con Google Pay. Para obtener información sobre las comisiones por transacción de los métodos de pago, consulta los [detalles de los precios](https://stripe.com/pricing/local-payment-methods). Google Pay les permite a los clientes efectuar pagos en tu aplicación o sitio web usando cualquier tarjeta de crédito o débito guardada en su cuenta de Google, incluidas las de Google Play, YouTube, Chrome o un dispositivo Android. Usa la API de Google Pay para solicitar una tarjeta de crédito o débito almacenada en la cuenta de Google de tu cliente. Google Pay es totalmente compatible con los productos y funcionalidades de Stripe (p. ej., pagos recurrentes), por lo que puedes usarlo en lugar de una forma de pago tradicional cada vez que sea posible. Úsalo para aceptar pagos por bienes tangibles, donaciones, *suscripciones* (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) y mucho más. > #### Condiciones de Google Pay > > Al integrar Google Pay, aceptas las [condiciones del servicio](https://payments.developers.google.com/terms/sellertos) de Google. #### Propiedades del método de pago - **Ubicaciones de los clientes** En todo el mundo, excepto India - **Moneda de pago** Ver [monedas de pago aceptadas](https://docs.stripe.com/currencies.md#presentment-currencies) - **Confirmación del pago** Iniciada por el cliente - **Familia de métodos de pago** Cartera - **Pagos recurrentes** Si - **Plazo de transferencia** Se aplica el plazo de transferencia estándar - **Soporte de Connect** Si - **Soporte para disputas** [Sí](https://docs.stripe.com/google-pay.md#disputed-payments) - **Compatibilidad de la captura manual** Si - **Reembolsos/reembolsos parciales** [Sí/Sí](https://docs.stripe.com/google-pay.md#refunds) #### Ubicaciones de la empresa Las cuentas de Stripe de todo el mundo, excepto de la India, pueden aceptar pagos de Google Pay en moneda local. #### Soporte de productos - Connect - Checkout - Payment Links - Elements - Subscriptions - Invoicing ## Cómo usar Stripe y Google Pay versus el sistema de facturación de Google Play Para la venta de bienes tangibles y servicios, en tu aplicación se puede aceptar Google Pay o cualquier otro método de pago admitido por Stripe. Esos pagos se procesan mediante Stripe, y solo tienes que pagar las [comisiones de procesamiento](https://stripe.com/pricing) que Stripe establece. Sin embargo, para las compras de productos y contenido digitales dentro de la aplicación se debe usar el [sistema de facturación de Google Play](https://developer.android.com/google/play/billing). Esos pagos son procesados por Google y están sujetos a sus comisiones de transacción. Para obtener más información sobre qué compras deben utilizar el sistema de facturación de Google Play, consulta las de Google Play [condiciones para desarrolladores](https://support.google.com/googleplay/android-developer/answer/10281818). # Android > This is a Android for when platform is android. View the full page at https://docs.stripe.com/google-pay?platform=android. ## Acepta un pago con Google Pay en tu aplicación para Android `GooglePayLauncher`: es parte del SDK para Android de Stripe y la forma más rápida y sencilla de empezar a aceptar Google Pay en tus aplicaciones para Android. ## Requisitos previos Para aceptar Google Pay en Android, necesitas lo siguiente: - Una `minSdkVersion` de `19` o superior. - Una `compileSdkVersion` de `28` o superior. Además, si deseas probar con tu propio dispositivo, debes [agregar un método de pago a tu cuenta de Google](https://support.google.com/wallet/answer/12058983?visit_id=637947092743186187-653786796&rd=1). ## Configura tu integración Esta guía supone que estás usando la versión más reciente del SDK para Android de Stripe. #### Groovy ```groovy dependencies { implementation 'com.stripe:stripe-android:23.1.0' } ``` Para usar Google Pay, primero habilita la API de Google Pay agregando lo siguiente a la etiqueta `` de tu **AndroidManifest.xml**: ```xml ... ``` Para obtener más detalles, consulta cómo [configurar la API de Google Pay](https://developers.google.com/pay/api/android/guides/setup) para Android en Google Pay. ## Crear un PaymentIntent ### Lado del servidor Crea un `PaymentIntent` en tu servidor con un [importe](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) y una [moneda](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Decide cuánto cobrar siempre del lado del servidor, un entorno de confianza, no del lado del cliente. Esto impide que clientes maliciosos puedan elegir sus propios precios. #### curl ```bash curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -d "amount"=1099 \ -d "currency"="usd" ``` ### Lado del cliente Un PaymentIntent incluye un *secreto de cliente* (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)). Puedes usar el secreto de cliente en tu aplicación Android para completar el proceso de pago en modo seguro sin volver a especificar el objeto PaymentIntent completo. En tu aplicación, solicita un PaymentIntent desde tu servidor y guarda el secreto de cliente. #### 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 } } ``` ## Agregar el botón de Google Pay Agrega el botón de Google Pay a tu aplicación siguiendo el [tutorial de Google](https://developers.google.com/pay/api/android/guides/tutorial#add-button). Esto garantiza que estés usando los recursos correctos. ## Crear una instancia de GooglePayLauncher A continuación, crea una instancia de [GooglePayLauncher](https://github.com/stripe/stripe-android/blob/master/payments-core/src/main/java/com/stripe/android/googlepaylauncher/GooglePayLauncher.kt) en tu `Activity` o `Fragment`. Esto debe hacerse en `Activity#onCreate()`. `GooglePayLauncher.Config` muestra las propiedades obligatorias y opcionales de la configuración de `GooglePayLauncher`. Consulta `GooglePayLauncher.Config` para obtener más detalles sobre las opciones de configuración. #### 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 } } ``` Después de crear una instancia de `GooglePayLauncher`, se llama a la instancia `GooglePayLauncher.ReadyCallback` con un marcador que indica si Google Pay está disponible y listo para usarse. Este marcador se puede utilizar para actualizar tu Interfaz de usuario (IU) a fin de indicarle al cliente que Google Pay está listo para usarse. #### 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 } } ``` ## Lanzar GooglePayLauncher Una vez que Google Pay esté disponible y tu aplicación haya obtenido el secreto de cliente del `PaymentIntent` o `SetupIntent`, lanza `GooglePayLauncher` utilizando el método correspondiente. Si confirmas un `PaymentIntent`, usa `GooglePayLauncher#presentForPaymentIntent(clientSecret)`. Si confirmas un `SetupIntent`, usa `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) } } } ``` ## Gestionar el resultado Finalmente, implementa `GooglePayLauncher.ResultCallback` para gestionar el resultado de la operación de `GooglePayLauncher`. El resultado puede ser `GooglePayLauncher.Result.Completed`, `GooglePayLauncher.Result.Canceled` o `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 } } } } ``` ## Cómo activar Google Pay Sigue las [instrucciones de Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) para solicitar acceso en el entorno de producción de la aplicación. Elige el tipo de integración **Puerta de enlace** cuando se te solicite y proporciona capturas de pantalla de tu aplicación para su revisión. Una vez que tu aplicación se haya aprobado, prueba tu integración en producción estableciendo el entorno en `GooglePayEnvironment.Production` y lanzando Google Pay desde una versión firmada de tu aplicación. Recuerda usar tus [claves de API](https://docs.stripe.com/keys.md) *activas* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Puedes usar un `PaymentIntent` con [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) para procesar una transacción sin capturar el pago. ### Prueba Google Pay Google te permite realizar pagos de prueba a través de su tarjeta [Test card suite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). El conjunto de pruebas admite el uso de [tarjetas de prueba](https://docs.stripe.com/testing.md) de Stripe. Debes probar Google Pay usando un dispositivo Android físico en lugar de un dispositivo simulado, en un país donde se admite Google Pay. Inicia sesión en una cuenta Google en tu dispositivo de prueba con una tarjeta real guardada en Google Wallet. ## Cómo crear un PaymentMethod Si confirmas el pago en tu servidor, puedes usar `GooglePayPaymentMethodLauncher` solo para recopilar un `PaymentMethod`, no para confirmar el pago. #### 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. El SDK nativo de React de Stripe es la forma más rápida y sencilla de empezar a aceptar Google Pay en tus aplicaciones nativas de React. El componente [PlatformPayButton](https://stripe.dev/stripe-react-native/api-reference/index.html#PlatformPayButton) incluye la interfaz de usuario requerida de Google y puedes utilizar los métodos `confirmPlatformPayPayment` y `createPlatformPayPaymentMethod` para cobrar o crear pagos en tu app sin problemas con una configuración mínima. > Si usas React Native y Expo, Expo Go no admite Google Pay. Para usar Google Pay con Expo, debes crear una [versión de desarrollo](https://docs.expo.dev/get-started/set-up-your-environment/?mode=development-build&platform=android). Si ya tienes un proyecto de Expo Go, puedes [migrarlo a una versión de desarrollo](https://docs.expo.dev/develop/development-builds/expo-go-to-dev-build/). ## Configurar Stripe [Lado del servidor] [Lado del cliente] ### Lado del servidor Esta integración necesita puntos de conexión en tu servidor que se comuniquen con la API de Stripe. Usa nuestras bibliotecas oficiales para acceder a la API de Stripe desde tu servidor: #### 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' ``` ### Lado del cliente El [SDK para React Native](https://github.com/stripe/stripe-react-native) es de código abierto y está plenamente documentado. Internamente, utiliza SDK para [iOS nativo](https://github.com/stripe/stripe-ios) y [Android](https://github.com/stripe/stripe-android). Para instalar el SDK para React Native de Stripe, ejecuta uno de los siguientes comandos en el directorio del proyecto (según el administrador de paquetes que utilices): #### hilado ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` A continuación, instala otras dependencias necesarias: - Para iOS, vaya al directorio **ios** y ejecute `pod install` para asegurarse de que también instala las dependencias nativas necesarias. - Para Android, no hay más dependencias para instalar. > Recomendamos seguir la [guía oficial de TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) para agregar soporte para TypeScript. ### Inicialización de Stripe Para inicializar Stripe en tu aplicación React Native, ajusta tu pantalla de pago con el componente `StripeProvider` o usa el método de inicialización `initStripe`. Solo se requiere la [clave publicable](https://docs.stripe.com/keys.md#obtain-api-keys) de la API en `publishableKey`. El siguiente ejemplo muestra cómo inicializar Stripe usando el componente `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 */} ); } ``` > Usa las [claves de prueba](https://docs.stripe.com/keys.md#obtain-api-keys) de la API durante las pruebas y el desarrollo, y tus claves para [modo activo](https://docs.stripe.com/keys.md#test-live-modes) cuando publiques tu aplicación. ## Habilitar Google Pay Para usar Google Pay, primero habilita la API de Google Pay agregando lo siguiente a la etiqueta `` de tu **AndroidManifest.xml**: ```xml ... ``` Para obtener más detalles, consulta cómo [configurar la API de Google Pay](https://developers.google.com/pay/api/android/guides/setup) para Android. ## Crear un PaymentIntent [Lado del servidor] Primero, crea un `PaymentIntent` en tu servidor y especifica el importe por cobrar y la moneda. Si ya tienes una integración que usa la [API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), agrega `card` a la lista de [tipos de métodos de pago](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) para tu `PaymentIntent` (este es también el método de pago predeterminado si no se define ningún método de pago): ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=card" \ -d amount=1099 \ -d currency=usd ``` El PaymentIntent incluye un *secreto de cliente* (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)). Puedes usar el secreto de cliente en tu aplicación React Native para completar el proceso de pago en modo seguro sin volver a especificar el objeto PaymentIntent completo. En tu aplicación, solicita un PaymentIntent desde tu servidor y almacena el secreto de cliente. ## Inicializar Google Pay [Lado del cliente] Primero, comprueba si el dispositivo es compatible con Google Pay llamando a `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 ( ... ); } ``` ## Presentar la hoja de Google Pay [Lado del cliente] Una vez que sepas que Google Pay está disponible y que tu aplicación obtuvo un secreto de cliente de `PaymentIntent` o `SetupIntent`, llama a `confirmPlatformPayPayment`. En cambio, si confirmas un `SetupIntent`, usa `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: Cómo crear un PaymentMethod [Lado del cliente] Si confirmas el pago en tu servidor, puedes usar Google Pay solo para recopilar un `PaymentMethod`, en lugar de para confirmar el pago. Para hacer esa llamada, usa el método `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 ( ); } ``` ## Cómo activar Google Pay Sigue las [instrucciones de Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) para solicitar acceso en el entorno de producción de la aplicación. Elige el tipo de integración **Puerta de enlace** cuando se te solicite y proporciona capturas de pantalla de tu aplicación para su revisión. Una vez que tu aplicación se haya aprobado, prueba tu integración en producción con `testEnv: false` y lanzando Google Pay desde una versión firmada de tu aplicación. Recuerda usar tus [claves de API](https://docs.stripe.com/keys.md) *activas* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Puedes usar un `PaymentIntent` con [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) para procesar una transacción sin capturar el pago. ### Prueba Google Pay Google te permite realizar pagos de prueba a través de su tarjeta [Test card suite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). El conjunto de pruebas admite el uso de [tarjetas de prueba](https://docs.stripe.com/testing.md) de Stripe. Debes probar Google Pay usando un dispositivo Android físico en lugar de un dispositivo simulado, en un país donde se admite Google Pay. Inicia sesión en una cuenta Google en tu dispositivo de prueba con una tarjeta real guardada en 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. ## Acepta Google Pay en la web Puedes aceptar pagos con Google Pay en la Web con [Checkout](https://docs.stripe.com/payments/checkout.md) o [Elements](https://docs.stripe.com/payments/elements.md) habilitando Google Pay en la [configuración de tus métodos de pago](https://dashboard.stripe.com/settings/payment_methods). El uso de Google Pay en Checkout no requiere implementación de código adicional. Para Elements, consulta las guías de [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element.md) o [Aceptar un pago](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout) para saber cómo agregar Google Pay a tu sitio. Tendrás que usar una página web HTTPS con un certificado validado por el dominio TLS para aceptar pagos de Google Pay en la web. ### Registra tu dominio con Google Pay Para usar Google Pay, debes registrar todos los dominios web que muestran un botón de Google Pay. Eso incluye dominios de nivel superior (por ejemplo, **stripe.com**) y subdominios (por ejemplo, **shop.stripe.com**), en producción y pruebas. > #### Subdominios > > `www` es un subdominio (por ejemplo, **www.stripe.com**) que también debes registrar. ```curl curl https://api.stripe.com/v1/payment_method_domains \ -u "<>:" \ -d "domain_name=example.com" ``` Cuando uses [cargos Direct](https://docs.stripe.com/connect/direct-charges.md) con *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), tendrás que configurar el dominio para cada cuenta conectada mediante la API. Esto no es un requisito para las cuentas conectadas que usan otros tipos de cargos. Después de registrar tus dominios, puedes efectuar pagos en tu sitio con tus claves de API activas. ## Prueba Google Pay Google te permite realizar pagos de prueba a través de su tarjeta [Test card suite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). Puedes utilizar las [tarjetas de prueba](https://docs.stripe.com/testing.md) de Stripe con el paquete de pruebas. Antes de poder utilizar una tarjeta de prueba de Stripe, debes añadir una tarjeta real a tu cartera para que se muestre Google Pay. Si no cumples los requisitos de dispositivo e integración, Stripe no interpretará Google Pay como opción de pago. Para solucionar problemas de interpretación con Google Pay, utiliza nuestra [página de prueba](https://docs.stripe.com/testing/wallets.md). ## Disputas Los usuarios deben autenticar los pagos con sus cuentas de Google Pay, lo que reduce el riesgo de fraude o de pagos no reconocidos. Sin embargo, los usuarios aún pueden disputar las transacciones después de completar el pago. Puedes enviar evidencia para responder a una disputa directamente. El proceso de disputa es el mismo que para los pagos con tarjeta. Obtén más información sobre cómo [gestionar disputas](https://docs.stripe.com/disputes/responding.md). ### Transferencia de responsabilidad para cargos en Google Pay Google Pay admite [transferencia de responsabilidad](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#disputed-payments) de forma global. Esto es así automáticamente para los usuarios de productos alojados en Stripe y que utilicen Stripe.js. Para transacciones con Visa fuera de un producto alojado en Stripe, debe habilitar la transferencia de responsabilidad en la consola de Google Pay & Wallet. Para ello, vaya a su ***Consola de Google Pay & Wallet***, seleccione ***Google Pay API*** en la barra de navegación de la izquierda y, a continuación, active ***Protección contra fraudes para tokens de dispositivos Visa*** para la protección de transferencia de responsabilidad. Existen tres casos de uso de las transacciones de Google Pay: 1. Si el usuario agrega una tarjeta a la aplicación Google Pay con su dispositivo móvil, esta tarjeta se guarda como un número de cuenta principal del dispositivo (DPAN) y admite la transferencia de responsabilidad de forma predeterminada. 1. Si el usuario agrega una tarjeta a Chrome o a una propiedad de Google (por ejemplo, YouTube o Play), se guarda como un número de cuenta principal de financiación (FPAN). Cuando usas [3D Secure](https://docs.stripe.com/payments/3d-secure.md), admitimos la transferencia de responsabilidad en todo el mundo para todas las redes principales, incluso Visa. Puedes personalizar [las reglas de Stripe Radar](https://docs.stripe.com/radar/rules.md#request-3d-secure) para solicitar la activación de 3D Secure. 1. Si el usuario selecciona Google Pay como método de pago en un sitio de ecommerce o en una aplicación que paga con Google Pay, las tarjetas se guardan como tokens de ecommerce que representan las tarjetas registradas. En este momento, los tokens de ecommerce no admiten la transferencia de responsabilidad ni la autenticación con 3D Secure. Para los usuarios de Sigma, la tabla `charges` contiene un campo `card_token_type` que indica el tipo de transacción de Google Pay. Una transacción con el FPAN establece `card_token_type` en `fpan`. Las transacciones con el DPAN y token de ecommerce establecen el `card_token_type` en `dpan_or_ecommerce_token`. ## Reembolsos Puedes reembolsar en forma parcial o total todos los pagos realizados correctamente con Google Pay. El proceso de reembolso es el mismo que para los pagos con tarjeta. Consulta [Reembolsa y cancela pagos](https://docs.stripe.com/refunds.md) para ver las instrucciones sobre cómo iniciar o gestionar los reembolsos.