# Google Pay

Learn how to accept payments using Google Pay.

For information on payment method transaction fees, refer to [pricing details](https://stripe.com/pricing/local-payment-methods).

Google Pay allows customers to make payments in your app or website using any credit or debit card saved to their Google Account, including those from Google Play, YouTube, Chrome, or an Android device. Use the Google Pay API to request any credit or debit card stored in your customer’s Google account.

Google Pay is fully compatible with Stripe’s products and features (for example, recurring payments), allowing you to use it in place of a traditional payment form whenever possible. Use it to accept payments for physical goods, donations, *subscriptions* (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), and so on.

> #### Google Pay terms
> 
> By integrating Google Pay, you agree to Google’s [terms of service](https://payments.developers.google.com/terms/sellertos).

#### Payment method properties

- **Customer locations**

  Worldwide except India

- **Presentment currency**

  See [supported presentment currencies](https://docs.stripe.com/currencies.md#presentment-currencies)

- **Payment confirmation**

  Customer-initiated

- **Payment method family**

  Wallet

- **Recurring payments**

  Yes

- **Payout timing**

  Standard payout timing applies

- **Connect support**

  Yes

- **Dispute support**

  [Yes](https://docs.stripe.com/google-pay.md#disputed-payments)

- **Manual capture support**

  Yes

- **Refunds / Partial refunds**

  [Yes / Yes](https://docs.stripe.com/google-pay.md#refunds)

#### Business locations

Stripe accounts worldwide except India can accept Google Pay payments with local currency settlement.

#### Product support

- Connect
- Checkout
- Payment Links
- Elements
- Subscriptions
- Invoicing

## Using Stripe and Google Pay versus the Google Play billing system

This guide explains how to configure your app to accept Google Pay for physical goods, services, and other eligible items. Stripe processes these payments, and you pay only Stripe’s [processing fees](https://stripe.com/pricing).

For digital products, content, and subscriptions sold in the US or the European Economic Area (EEA), your Android app can accept payments directly in-app through a third-party payment processor such as Stripe. You can use these payment UIs:

- [Mobile Payment Element](https://docs.stripe.com/payments/mobile.md) to accept payments directly in-app
- [Stripe Checkout](https://docs.stripe.com/mobile/digital-goods/checkout.md) to redirect customers to a Stripe-hosted payment page
- [Payment Links](https://docs.stripe.com/mobile/digital-goods/payment-links.md) for a limited number of products and prices

For more information about which purchases must use the Google Play billing system, see Google Play’s [developer terms](https://support.google.com/googleplay/android-developer/answer/10281818).

# Android


## Accept a payment using Google Pay in your Android app 

`GooglePayLauncher`, part of the Stripe Android SDK, is the fastest and easiest way to start accepting Google Pay in your Android apps.

## Prerequisites 

To support Google Pay in Android, you need the following:

- A `minSdkVersion` of `19` or higher.
- A `compileSdkVersion` of `28` or higher.

Additionally, if you wish to test with your own device, you need to [add a payment method to your Google Account](https://support.google.com/wallet/answer/12058983?visit_id=637947092743186187-653786796&rd=1).

## Set up your integration

This guide assumes you’re using the latest version of the Stripe Android SDK.

#### Groovy

```groovy
dependencies {
    implementation 'com.stripe:stripe-android:23.9.1'
}
```

To use Google Pay, first enable the Google Pay API by adding the following to the `<application>` tag of your **AndroidManifest.xml**:

```xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>
```

For more details, see Google Pay’s [Set up Google Pay API](https://developers.google.com/pay/api/android/guides/setup) for Android.

## Create a PaymentIntent

### Server-side 

Create a `PaymentIntent` on your server with an [amount](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) and [currency](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Always decide how much to charge on the server side, a trusted environment, as opposed to the client side. This prevents malicious customers from choosing their own prices.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd"
```

### Client-side 

A PaymentIntent includes a *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)). You can use the client secret in your Android app to securely complete the payment process instead of passing the entire PaymentIntent object. In your app, request a PaymentIntent from your server and store its client secret.

#### Java

```java
public class CheckoutActivity extends AppCompatActivity {

    private String paymentIntentClientSecret;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        // ...
        startCheckout();
    }

    private void startCheckout() {
        // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret
        // Click View full sample to see a complete implementation
    }
}
```

## Add the Google Pay button

Add the Google Pay button to your app by following [Google’s tutorial](https://developers.google.com/pay/api/android/guides/tutorial#add-button). This ensures you’re using the correct assets.

## Instantiate GooglePayLauncher

Next, create an instance of [GooglePayLauncher](https://github.com/stripe/stripe-android/blob/master/payments-core/src/main/java/com/stripe/android/googlepaylauncher/GooglePayLauncher.kt) in your `Activity` or `Fragment`. This must be done in `Activity#onCreate()`.

`GooglePayLauncher.Config` exposes both required and optional properties that configure `GooglePayLauncher`. See `GooglePayLauncher.Config` for more details on the configuration options.

#### Java

```java
import com.google.android.gms.wallet.button.PayButton

public class CheckoutActivity extends AppCompatActivity {
    private PayButton googlePayButton;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.checkout_activity);

        PaymentConfiguration.init(this, PUBLISHABLE_KEY);

        googlePayButton = /* TODO: Initialize button by following Google's guide. */

        final GooglePayLauncher googlePayLauncher = new GooglePayLauncher(
                this,
                new GooglePayLauncher.Config(
                        GooglePayEnvironment.Test,
                        "US",
                        "Widget Store"
                ),
                this::onGooglePayReady,
                this::onGooglePayResult
        );

        // launch `GooglePayLauncher` to confirm a Payment Intent
        googlePayButton.setOnClickListener(
                v -> googlePayLauncher.presentForPaymentIntent(clientSecret)
        );
    }

    private void onGooglePayReady(boolean isReady) {
        // implemented below
    }

    private void onGooglePayResult(@NotNull GooglePayLauncher.Result result) {
        // implemented below
    }
}
```

After instantiating `GooglePayLauncher`, the `GooglePayLauncher.ReadyCallback` instance is called with a flag indicating whether Google Pay is available and ready to use. This flag can be used to update your UI to indicate to your customer that Google Pay is ready to be used.

#### Java

```java
import com.google.android.gms.wallet.button.PayButton

public class CheckoutActivity extends AppCompatActivity {
    // continued from above

    private PayButton googlePayButton;

    private void onGooglePayReady(boolean isReady) {
        googlePayButton.setEnabled(isReady);
    }
}
```

## Launch GooglePayLauncher

After Google Pay is available and your app has obtained a `PaymentIntent` or `SetupIntent` client secret, launch `GooglePayLauncher` using the appropriate method. When confirming a `PaymentIntent`, use `GooglePayLauncher#presentForPaymentIntent(clientSecret)`. When confirming a `SetupIntent`, use `GooglePayLauncher#presentForSetupIntent(clientSecret)`.

#### Java

```java
import com.google.android.gms.wallet.button.PayButton

public class CheckoutActivity extends AppCompatActivity {
    // fetch client_secret from backend
    private String clientSecret = "";

    private PayButton googlePayButton;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // instantiate `googlePayLauncher`

        // launch `GooglePayLauncher` to confirm a Payment Intent
        googlePayButton.setOnClickListener(
                v -> googlePayLauncher.presentForPaymentIntent(clientSecret)
        );
    }
}
```

## Handle the result

Finally, implement `GooglePayLauncher.ResultCallback` to handle the result of the `GooglePayLauncher` operation.

The result can be `GooglePayLauncher.Result.Completed`, `GooglePayLauncher.Result.Canceled`, or `GooglePayLauncher.Result.Failed`.

#### Java

```java
public class CheckoutActivity extends AppCompatActivity {

    private void onGooglePayResult(@NotNull GooglePayLauncher.Result result) {
        if (result instanceof GooglePayLauncher.Result.Completed) {
            // Payment succeeded, show a receipt view
        } else if (result instanceof GooglePayLauncher.Result.Canceled) {
            // User canceled the operation
        } else if (result instanceof GooglePayLauncher.Result.Failed) {
            // Operation failed; inspect `result.getError()` for more details
        }
    }
}
```

## Go live with Google Pay

Follow [Google’s instructions](https://developers.google.com/pay/api/android/guides/test-and-deploy/request-prod-access) to request production access for your app. Choose the integration type **Gateway** when prompted, and provide screenshots of your app for review.

After your app has been approved, test your integration in production by setting the environment to `GooglePayEnvironment.Production`, and launching Google Pay from a signed, release build of your app. Remember to use your *live mode* (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). You can use a `PaymentIntent` with [`capture_method` = `manual`](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) to process a transaction without capturing the payment.

### Test Google Pay

Google allows you to make test payments through their [Test card suite](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). The test suite supports using Stripe [test cards](https://docs.stripe.com/testing.md).

You must test Google Pay using a physical Android device instead of a simulated device, in a country where Google Pay is supported. Log in to a Google account on your test device with a real card saved to Google Wallet.

## Creating a PaymentMethod

If you confirm your payment on your server, you can use `GooglePayPaymentMethodLauncher` to only collect a `PaymentMethod` instead of confirm payment.

#### Java

```java
import com.google.android.gms.wallet.button.PayButton

public class CheckoutActivity extends AppCompatActivity {
    private PayButton googlePayButton;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.checkout_activity);

        PaymentConfiguration.init(this, PUBLISHABLE_KEY);

        googlePayButton = /* TODO: Initialize button by following Google's guide. */

        final GooglePayPaymentMethodLauncher googlePayLauncher = new GooglePayPaymentMethodLauncher(
                this,
                new GooglePayPaymentMethodLauncher.Config(
                        GooglePayEnvironment.Test,
                        "FR",
                        "Widget Store"
                ),
                this::onGooglePayReady,
                this::onGooglePayResult
        );

        // launch `GooglePayPaymentMethodLauncher` to create a PaymentMethod
        googlePayButton.setOnClickListener(
                v -> googlePayLauncher.present("EUR", 2500)
        );
    }

    private void onGooglePayReady(boolean isReady) {
        googlePayButton.setEnabled(isReady);
    }

    private void onGooglePayResult(@NotNull GooglePayPaymentMethodLauncher.Result result) {
        if (result instanceof GooglePayPaymentMethodLauncher.Result.Completed) {
            // Payment details successfully captured.
            // Send the paymentMethodId to your server to finalize payment.
            final String paymentMethodId =
                ((GooglePayPaymentMethodLauncher.Result.Completed) result).getPaymentMethod().id;
        } else if (result instanceof GooglePayPaymentMethodLauncher.Result.Canceled) {
            // User canceled the operation
        } else if (result instanceof GooglePayPaymentMethodLauncher.Result.Failed) {
            // Operation failed; inspect `result.getError()` for the exception
        }
    }
}
```


## Disputes 

Users must authenticate payments with their Google Pay accounts, which reduces the risk of fraud or unrecognized payments. However, users can still dispute transactions after they complete payment. You can submit evidence to contest a dispute directly. The dispute process is the same as that for card payments. Learn how to [manage disputes](https://docs.stripe.com/disputes/responding.md).

### Liability shift for Google Pay charges

Google Pay supports [liability shift](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#disputed-payments) globally. This is true automatically for users on Stripe-hosted products and using Stripe.js. For Visa transactions outside of a Stripe-hosted product, you must enable liability shift in the Google Pay & Wallet Console. To do so, go to your ***Google Pay & Wallet Console***, select ***Google Pay API*** in the navigation bar on the left, and then enable ***Fraud Liability Protection for Visa Device Tokens*** for liability shift protection.

There are three use cases of Google Pay transactions:

1. If the user adds a card to the Google Pay app using their mobile device, this card is saved as a Device Primary Account Number (DPAN), and it supports liability shift by default.
1. If the user adds a card to Chrome or a Google property (for example, YouTube, or Play), it’s saved as a Funding Primary Account Number (FPAN). When you use [3D Secure](https://docs.stripe.com/payments/3d-secure.md), we globally support liability shift for all major networks, including Visa. You can customize [Stripe Radar rules](https://docs.stripe.com/radar/rules.md#request-3d-secure) to request activation of 3D Secure.
1. If the user selects Google Pay as the payment method on an e-commerce site or in an app that pays with Google Pay, the cards are saved as e-commerce tokens that represent the cards on file. Neither liability shift nor 3D Secure are supported for e-commerce tokens at this time.

For Sigma users, the `charges` table contains a `card_token_type` field that indicates the Google Pay transaction type. An FPAN transaction sets the `card_token_type` to `fpan`. DPAN and ecommerce token transactions set the `card_token_type` to `dpan_or_ecommerce_token`.

## Refunds

You can partially or fully refund any successful Google Pay payment. The refund process is the same as that for card payments. See [Refund and cancel payments](https://docs.stripe.com/refunds.md) for instructions on initiating or managing refunds.