# Google Pay Receba pagamentos pelo Google Pay. Para obter informações sobre tarifas de transação de formas de pagamento, consulte os [detalhes de preços](https://stripe.com/pricing/local-payment-methods). O Google Pay permite fazer pagamentos no seu aplicativo ou site com qualquer cartão de crédito ou débito salvo na conta do Google, inclusive no Google Play, YouTube, Chrome ou aparelho Android. Use a API Google Pay para solicitar cartões de crédito ou débito armazenados na conta do seu cliente. O Google Pay é totalmente compatível com os produtos e recursos da Stripe (por exemplo, pagamentos recorrentes), permitindo que você o utilize no lugar de uma forma de pagamento tradicional sempre que for possível. Use-o para aceitar pagamentos referentes a produtos físicos, doações, *assinaturas* (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) e assim por diante. > #### Termos do Google Pay > > Ao integrar o Google Pay, você aceita os [termos de serviço](https://payments.developers.google.com/terms/sellertos) do Google. #### Propriedades da forma de pagamento - **Localização dos clientes** Em todo o mundo, exceto Índia - **Moeda de apresentação** Ver [moedas de apresentação aceitas](https://docs.stripe.com/currencies.md#presentment-currencies) - **Confirmação do pagamento** Iniciada pelo cliente - **Família da forma de pagamento** Carteira - **Pagamentos recorrentes** Sim - **Frequência de repasses** Cronograma de repasses padrão - **Aceita Connect** Sim - **Aceita contestações** [Sim](https://docs.stripe.com/google-pay.md#disputed-payments) - **Aceita captura manual** Sim - **Reembolsos totais/parciais** [Sim/Sim](https://docs.stripe.com/google-pay.md#refunds) #### Locais da empresa Contas Stripe em todo o mundo, exceto na Índia, podem aceitar pagamentos Google Pay com liquidação em moeda local. #### Suporte do produto - Connect - Checkout - Payment Links - Elements - Subscriptions - Invoicing ## Uso da Stripe e Google Pay x sistema de faturamento do Google Play Este guia explica como configurar seu aplicativo para aceitar Google Pay para bens físicos, serviços e outros itens elegíveis. A Stripe processa esses pagamentos, e você paga apenas as [tarifas de processamento](https://stripe.com/pricing) da Stripe. Para produtos digitais, conteúdo e assinaturas vendidos nos EUA ou no Espaço Econômico Europeu (EEA), seu aplicativo Android pode aceitar pagamentos diretamente no aplicativo por meio de processador externo de pagamentos, como a Stripe. Você pode usar estas interfaces de pagamento: - [Mobile Payment Element](https://docs.stripe.com/payments/mobile.md) para aceitar pagamentos diretamente no aplicativo - [Stripe Checkout](https://docs.stripe.com/mobile/digital-goods/checkout.md) para redirecionar os clientes para uma página de pagamento hospedada pela Stripe - [Payment Links](https://docs.stripe.com/mobile/digital-goods/payment-links.md) para um número limitado de produtos e preços Para obter mais informações sobre quais compras devem usar o sistema de faturamento do Google Play, consulte os [termos para desenvolvedores](https://support.google.com/googleplay/android-developer/answer/10281818) do 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. ## Aceitar um pagamento usando Google Pay em um aplicativo Android O `GooglePayLauncher`, parte do SDK para Android da Stripe, é a forma mais rápida e fácil de começar a aceitar o Google Pay em aplicativos Android. ## Pré-requisitos Para aceitar o Google Pay no Android, você precisa do seguinte: - Uma `minSdkVersion` de `19` ou superior. - Uma `compileSdkVersion` de `28` ou superior. Além disso, se quiser testar com seu próprio dispositivo, você precisa [adicionar uma forma de pagamento à sua Conta do Google](https://support.google.com/wallet/answer/12058983?visit_id=637947092743186187-653786796&rd=1). ## Configurar a integração Este guia considera que você está usando a versão mais recente do SDK para Android da Stripe. #### Excelente ```groovy dependencies { implementation 'com.stripe:stripe-android:23.3.0' } ``` Para usar o Google Pay, habilite a API Google Pay adicionando o seguinte à `` tag do seu **AndroidManifest.xml**: ```xml ... ``` Veja mais detalhes na [Configuração da API Google Pay](https://developers.google.com/pay/api/android/guides/setup) do Google Pay para Android. ## Crie um PaymentIntent ### Lado do servidor Crie um `PaymentIntent` no seu servidor com um [valor](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) e [moedas](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Sempre defina o valor a ser cobrado no lado do servidor, um ambiente confiável, e não no lado do cliente. Isso evita que clientes mal-intencionados escolham seus próprios preços. #### curl ```bash curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -d "amount"=1099 \ -d "currency"="usd" ``` ### Lado do cliente Um PaymentIntent inclui um *segredo do 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)). Você pode usar o segredo do cliente no seu app Android para concluir o processo de pagamento com segurança, em vez de repassar todo o objeto PaymentIntent. No seu aplicativo, solicite um PaymentIntent ao seu servidor e armazene o respectivo segredo do 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 } } ``` ## Adicionar o botão do Google Pay Adicione o botão do Google Pay ao seu aplicativo seguindo o [tutorial do Google](https://developers.google.com/pay/api/android/guides/tutorial#add-button). Isso garante o uso dos ativos corretos. ## Instanciar o GooglePayLauncher Em seguida, crie uma instância de [GooglePayLauncher](https://github.com/stripe/stripe-android/blob/master/payments-core/src/main/java/com/stripe/android/googlepaylauncher/GooglePayLauncher.kt) em `Activity` ou `Fragment`. Isso pode ser feito em `Activity#onCreate()`. `GooglePayLauncher.Config` expõe propriedades obrigatórias e opcionais que configuram `GooglePayLauncher`. Consulte `GooglePayLauncher.Config` para ver mais detalhes sobre as opções de configuração. #### 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 } } ``` Depois de instanciar `GooglePayLauncher`, a instância de `GooglePayLauncher.ReadyCallback` é chamada com um sinalizador que indica se o Google Play está disponível e pronto para uso. Esse sinalizador pode ser usado para atualizar a IU, indicando ao cliente que o Google Pay está pronto para uso. #### 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 } } ``` ## Lançar o GooglePayLauncher Depois de o Google Pay estar disponível e o aplicativo obter um segredo do cliente de `PaymentIntent` ou `SetupIntent`, lance `GooglePayLauncher` usando o método adequado. Para confirmar um `PaymentIntent`, use `GooglePayLauncher#presentForPaymentIntent(clientSecret)`. Para confirmar um `SetupIntent`, use `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) } } } ``` ## Gerenciar o resultado Por fim, implemente `GooglePayLauncher.ResultCallback` para gerenciar o resultado da operação `GooglePayLauncher`. O resultado pode ser `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 } } } } ``` ## Entrar em produção com o Google Pay Siga as [instruções do Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) para solicitar acesso de produção para seu aplicativo. Escolha o tipo de integração **Gateway** quando solicitado e forneça capturas de tela do seu aplicativo para análise. Após a aprovação do aplicativo, teste sua integração em produção definindo o ambiente como `GooglePayEnvironment.Production` e iniciando o Google Pay em uma versão assinada do seu aplicativo. Lembre-se de usar suas [chaves de API](https://docs.stripe.com/keys.md) do *modo de produção* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Você pode usar um `PaymentIntent` com [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) para processar uma transação sem capturar o pagamento. ### Testar Google Pay O Google permite que você faça pagamentos de teste por meio de seu [Pacote de cartão de teste](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). O Pacote de cartão de teste é compatível com os [cartões de teste](https://docs.stripe.com/testing.md) da Stripe. Você precisa testar o Google Pay usando um dispositivo Android físico em vez de um dispositivo simulado, em um país onde o Google Pay é compatível. Faça login em uma conta do Google em seu dispositivo de teste com um cartão real salvo na Carteira do Google. ## Criar um PaymentMethod Se você confirmar o pagamento no servidor, poderá usar `GooglePayPaymentMethodLauncher` para somente coletar um `PaymentMethod`, em vez de confirmar o pagamento. #### 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. O SDK do React Native da Stripe é a maneira mais rápida e simples de começar a aceitar Google Pay nos seus aplicativos React Native. O componente [PlatformPayButton](https://stripe.dev/stripe-react-native/api-reference/index.html#PlatformPayButton) inclui a IU obrigatória do Google, e você pode usar os métodos `confirmPlatformPayPayment` e `createPlatformPayPaymentMethod` para coletar ou criar pagamentos no seu aplicativo facilmente e com o mínimo de configuração. > Se você usa o React Native e a Expo, a Expo Go não aceita o Google Pay. Para usar o Google Pay com a Expo, você precisa criar uma [versão de desenvolvimento](https://docs.expo.dev/get-started/set-up-your-environment/?mode=development-build&platform=android). Se você já tem um projeto da Expo Go, pode [migrá-lo para uma versão de desenvolvimento](https://docs.expo.dev/develop/development-builds/expo-go-to-dev-build/). ## Configurar a Stripe [Lado do servidor] [Lado do cliente] ### Servidor Esta integração exige que os endpoints do seu servidor se comuniquem com a API da Stripe. Use nossas bibliotecas oficiais para acessar a API da Stripe a partir do seu 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' ``` ### Cliente O [SDK do React Native](https://github.com/stripe/stripe-react-native) é de código aberto e totalmente documentado. Internamente, utiliza as SDKs de [iOS nativo](https://github.com/stripe/stripe-ios) e [Android](https://github.com/stripe/stripe-android). Para instalar o SDK do React Native da Stripe, execute um dos seguintes comandos no diretório do seu projeto (dependendo de qual gerenciador de pacotes você usa): #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Em seguida, instale algumas outras dependências necessárias: - Para iOS, vá para o diretório **ios** e execute `pod install` para garantir a instalação das dependências nativas necessárias. - Para Android, não há mais dependências para instalar. > Recomendamos seguir o [guia oficial do TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) para adicionar suporte ao TypeScript. ### Inicialização da Stripe Para inicializar a Stripe no aplicativo React Native, insira sua tela de pagamento com o componente `StripeProvider` ou use o método de inicialização `initStripe`. Somente a [chave da API publicável](https://docs.stripe.com/keys.md#obtain-api-keys) em `publishableKey` é necessária. O exemplo a seguir mostra como inicializar a Stripe usando o 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 */} ); } ``` > Use suas [chaves de API de teste](https://docs.stripe.com/keys.md#obtain-api-keys) enquanto testa e desenvolve, e as chaves de [modo de produção](https://docs.stripe.com/keys.md#test-live-modes) quando publica seu aplicativo. ## Ativar Google Pay Para usar o Google Pay, habilite a API Google Pay adicionando o seguinte à `` tag do seu **AndroidManifest.xml**: ```xml ... ``` Veja mais detalhes na [Configuração da API Google Pay](https://developers.google.com/pay/api/android/guides/setup) do Google Pay para Android. ## Crie um PaymentIntent [Lado do servidor] Primeiro, crie um `PaymentIntent` no seu servidor e especifique o valor a ser coletado e a moeda. Se já tiver uma integração que usa a [API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), adicione `card` à lista de [tipos de forma de pagamento](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) para o seu `PaymentIntent` (essa também é a forma de pagamento padrão se nenhuma for informada): ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d "payment_method_types[]=card" \ -d amount=1099 \ -d currency=usd ``` Um PaymentIntent inclui um *client secret* (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))segredo do cliente. Você pode usar o segredo do cliente no aplicativo React Native para concluir o processo de pagamento em vez de passar de volta todo o objeto PaymentIntent. No aplicativo, solicite um PaymentIntent do seu servidor e armazene o segredo do cliente. ## Inicializar o Google Pay [Do lado do cliente] Primeiro, verifique se o dispositivo aceita ou não o Google Pay chamando `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 ( ... ); } ``` ## Apresentar a planilha do Google Pay [Do lado do cliente] Após saber que o Google Pay está disponível e que seu aplicativo obteve um segredo do cliente `PaymentIntent` ou `SetupIntent`, chame `confirmPlatformPayPayment`. Ao confirmar um `SetupIntent`, use `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: Criar um PaymentMethod [Do lado do cliente] Se você confirmar seu pagamento no servidor, poderá usar o Google Pay somente para coletar um `PaymentMethod` em vez de confirmar um pagamento. Para fazer essa chamada, use o 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 ( ); } ``` ## Entrar em produção com o Google Pay Siga as [instruções do Google](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) para solicitar acesso de produção para seu aplicativo. Escolha o tipo de integração **Gateway** quando solicitado e forneça capturas de tela do seu aplicativo para análise. Após a aprovação do aplicativo, teste sua integração em produção usado `testEnv: false` e iniciando o Google Pay em uma versão assinada do seu aplicativo. Lembre-se de usar seu *modo de produção* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments) [API keys](https://docs.stripe.com/keys.md). Você pode usar um `PaymentIntent` com [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) para processar uma transação sem capturar o pagamento. ### Testar Google Pay O Google permite que você faça pagamentos de teste por meio de seu [Pacote de cartão de teste](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). O Pacote de cartão de teste é compatível com os [cartões de teste](https://docs.stripe.com/testing.md) da Stripe. Você precisa testar o Google Pay usando um dispositivo Android físico em vez de um dispositivo simulado, em um país onde o Google Pay é compatível. Faça login em uma conta do Google em seu dispositivo de teste com um cartão real salvo na Carteira do Google. # Web > This is a Web for when platform is web. View the full page at https://docs.stripe.com/google-pay?platform=web. ## Aceitar Google Pay na web Você pode aceitar pagamentos com Google Pay na internet usando o [Checkout](https://docs.stripe.com/payments/checkout.md) ou o [Elements](https://docs.stripe.com/payments/elements.md), ativando o Google Pay nas [configurações das formas de pagamento](https://dashboard.stripe.com/settings/payment_methods). Usar o Google Pay no Checkout não requer implementação adicional de código. Para o Elements, consulte os guias [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element.md) ou [Como aceitar um pagamento](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout) para saber como adicionar o Google Pay ao seu site. Você precisará veicular de uma página HTTPS com um certificado validado por domínio TLS para aceitar pagamentos do Google Pay na web. ### Registre seu domínio com Google Pay Para integrar o Google Pay, é obrigatório registrar todos os domínios da Web onde o botão do Google Pay será exibido. Isso abrange tanto domínios principais (como **stripe.com**) quanto subdomínios (como **shop.stripe.com**), tanto em ambiente de produção quanto de testes. > #### Sobre os subdomínios > > `www` é um subdomínio (por exemplo, **www.stripe.com**) que você também deve registrar. Registre seu domínio na página [Domínios de formas de pagamento](https://dashboard.stripe.com/settings/payment_method_domains) no Dashboard ou use a API com sua chave secreta de produção, como mostrado no exemplo a seguir. Registre seu domínio apenas uma vez por conta. ```curl curl https://api.stripe.com/v1/payment_method_domains \ -u "<>:" \ -d "domain_name=example.com" ``` Ao utilizar [Direct Charges](https://docs.stripe.com/connect/direct-charges.md) em conjunto com o *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), é necessário configurar o domínio individualmente para cada conta conectada via API. Esse passo não se aplica a contas que utilizam modalidades distintas de cobrança. Após registrar seus domínios, faça pagamentos no seu site com as chaves de API em modo de produção. ## Testar Google Pay A Google permite que você faça pagamentos de teste por meio do [Test card suite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). Você pode usar [cartões de teste](https://docs.stripe.com/testing.md) da Stripe com o test suite. Antes de usar um cartão de teste da Stripe, você precisa adicionar um cartão real à sua carteira para exibir o Google Pay. Se você não atender aos requisitos do dispositivo e de integração, a Stripe não mostrará o Google Pay como uma opção de pagamento. Para resolver problemas de exibição no Google Pay, use nossa [página de teste](https://docs.stripe.com/testing/wallets.md). ## Contestações Os usuários precisam autenticar os pagamentos com as contas do Google Pay, o que reduz o risco de fraude ou pagamentos não reconhecidos. No entanto, os usuários ainda podem contestar transações após finalizarem o pagamento. Você pode enviar comprovantes para refutar diretamente uma contestação. O processo de contestação é o mesmo dos pagamentos com cartão. Saiba como [gerenciar contestações](https://docs.stripe.com/disputes/responding.md). ### Transferência de responsabilidade para cobranças do Google Pay O Google Pay aceita [transferência de responsabilidade](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#disputed-payments) no mundo todo. Isso ocorre automaticamente para os usuários em produtos hospedados pela Stripe e que usam o Stripe.js. Para transações da Visa fora de um produto hospedado pela Stripe, você deve habilitar a transferência de responsabilidade no console do Google Pay e Google Wallet. Para fazer isso, vá para o ***Console do Google Pay e Google Wallet***, selecione ***API do Google Pay*** na barra de navegação à esquerda e ative a ***Proteção de responsabilidade por fraude para tokens de dispositivo Visa*** para proteção de transferência de responsabilidade. Há três casos de uso de transações do Google Pay: 1. Se o usuário adicionar um cartão ao aplicativo Google Pay usando o dispositivo móvel, esse cartão é salvo como Número de Conta Principal de Dispositivo (DPAN) e aceita transferência de responsabilidade automaticmente. 1. Se o usuário adicionar um cartão ao Chrome ou a uma propriedade do Google (como YouTube ou Play), o cartão será salvo como FPAN (Número de conta primária de financiamento). Quando você usa o [3D Secure](https://docs.stripe.com/payments/3d-secure.md), aceitamos globalmente a transferência de responsabilidade para todas as principais redes, incluindo a Visa. Você pode personalizar as [regras do Stripe Radar](https://docs.stripe.com/radar/rules.md#request-3d-secure) para solicitar a ativação de 3D Secure. 1. Se o usuário selecionar o Google Pay como forma de pagamento em um site de e-commerce ou em um aplicativo que paga com Google Pay, os cartões são salvos como tokens de e-commerce que representam os cartões registrados. A transferência de responsabilidade e o 3D Secure não são aceitos para tokens de e-commerce no momento. Para usuários do Sigma, a tabela de `charges` contém um campo `card_token_type` que indica o tipo de transação do Google Pay. Uma transação FPAN define o `card_token_type` como `fpan`. Transações de token DPAN e e-commerce definem o `card_token_type` como `dpan_or_ecommerce_token`. ## Reembolsos Você pode reembolsar de forma parcial ou total qualquer pagamento bem-sucedido do Google Pay. O processo de reembolso é o mesmo dos pagamentos com cartão. Consulte [Reembolsar e cancelar pagamentos](https://docs.stripe.com/refunds.md) para obter instruções sobre como iniciar ou gerenciar reembolsos.