> ## Documentation Index
> Fetch the complete documentation index at: https://docs.crossmint.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Google Pay

> Enable Google Pay for onramp transactions in React Native and Android native apps

<Note>This guide is for **mobile apps only** (React Native and Android native). On web, Google Pay works out of the box — see the [React Quickstart](/onramp/quickstarts/react).</Note>

This guide covers how to enable Google Pay for onramp flows in **React Native** and **Android native (Kotlin)** applications. Mobile apps require additional native configuration that web apps do not need.

## Overview

When properly configured, users see the native Android Google Pay sheet, providing seamless access to payment credentials stored in Google Wallet without leaving your app.

| Platform                   | Setup Required         |
| :------------------------- | :--------------------- |
| Web (React, Next.js, etc.) | Enable via props only  |
| React Native (Expo)        | Expo plugin + rebuild  |
| React Native (Bare)        | Manual Android config  |
| Android Native (Kotlin)    | AndroidManifest config |

## Mobile SDK Integration

<Tabs>
  <Tab title="React Native">
    ### Prerequisites

    * React Native project with Expo or bare workflow
    * Crossmint account with API keys
    * Android device or emulator with Google Play Services

    <Steps>
      <Step title="Install Dependencies">
        ```shell theme={null}
        pnpm add @crossmint/client-sdk-react-native-ui
        ```

        The SDK includes `react-native-webview` as a dependency. If you need to install it separately, ensure version **13.15.0 or higher**:

        ```shell theme={null}
        pnpm add react-native-webview@^13.15.0
        ```
      </Step>

      <Step title="Configure the Expo Plugin">
        Update your `app.json` to enable Google Pay:

        ```json theme={null}
        {
          "expo": {
            "plugins": [
              [
                "@crossmint/client-sdk-react-native-ui",
                {
                  "enableGooglePay": true
                }
              ]
            ]
          }
        }
        ```

        <Warning>
          This plugin modifies native Android permissions required for Google Pay. The app must be rebuilt after adding this configuration.
        </Warning>
      </Step>

      <Step title="Rebuild Your App">
        Hot reload cannot apply the permission changes. You must rebuild:

        ```shell theme={null}
        npx expo run:android
        ```

        Or for bare React Native:

        ```shell theme={null}
        npx react-native run-android
        ```
      </Step>

      <Step title="Enable Google Pay in the Checkout Component">
        When creating the onramp checkout, enable Google Pay in the payment configuration:

        ```jsx theme={null}
        import {
            CrossmintEmbeddedCheckout,
            CrossmintProvider,
        } from "@crossmint/client-sdk-react-native-ui";

        export default function OnrampScreen() {
            return (
                <CrossmintProvider apiKey="YOUR_CLIENT_SIDE_API_KEY">
                    <CrossmintEmbeddedCheckout
                        orderId={order.orderId}
                        clientSecret={order.clientSecret}
                        payment={{
                            crypto: { enabled: false },
                            fiat: {
                                enabled: true,
                                allowedMethods: {
                                    card: true,
                                    applePay: false,
                                    googlePay: true,
                                },
                            },
                        }}
                    />
                </CrossmintProvider>
            );
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Android Native (Kotlin)">
    <Note>
      The Kotlin SDK is currently in **Beta**.
    </Note>

    ### Prerequisites

    * Minimum Android SDK version 24 (Android 7.0)
    * Jetpack Compose
    * Crossmint account with API keys

    <Steps>
      <Step title="Add the SDK Dependency">
        In your app-level `build.gradle.kts`:

        ```kotlin theme={null}
        dependencies {
            implementation("com.crossmint:crossmint-sdk-android:0.0.9")
        }
        ```
      </Step>

      <Step title="Configure AndroidManifest.xml">
        Add the required query intents to enable Google Pay functionality:

        ```xml theme={null}
        <manifest xmlns:android="http://schemas.android.com/apk/res/android">
            <queries>
                <intent>
                    <action android:name="org.chromium.intent.action.PAY"/>
                </intent>
                <intent>
                    <action android:name="org.chromium.intent.action.IS_READY_TO_PAY"/>
                </intent>
                <intent>
                    <action android:name="org.chromium.intent.action.UPDATE_PAYMENT_DETAILS"/>
                </intent>
            </queries>
        </manifest>
        ```
      </Step>

      <Step title="Enable Google Pay in the Checkout Component">
        ```kotlin theme={null}
        import com.crossmint.kotlin.checkout.CheckoutEnvironment
        import com.crossmint.kotlin.checkout.CrossmintEmbeddedCheckout
        import com.crossmint.kotlin.checkout.models.*

        CrossmintEmbeddedCheckout(
            orderId = "YOUR_ORDER_ID",
            clientSecret = "YOUR_CLIENT_SECRET",
            payment = CheckoutPayment(
                crypto = CheckoutCryptoPayment(enabled = false),
                fiat = CheckoutFiatPayment(
                    enabled = true,
                    allowedMethods = CheckoutAllowedMethods(
                        googlePay = true,
                        applePay = false,
                        card = true
                    )
                )
            ),
            environment = CheckoutEnvironment.STAGING
        )
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Google Pay Production Approval

Google Pay works immediately in **staging** environments. For **production**, Google requires explicit approval of your app.

<AccordionGroup>
  <Accordion title="Step 1: Create Your Business Profile">
    1. Navigate to the <a href="https://pay.google.com/business/console" target="_blank">Google Pay & Wallet Console</a>
    2. Select "Merchant" as your business type
    3. Complete all business profile information
    4. Navigate to **Google Pay API** and click "Get Started"
    5. Accept the Google Pay API Terms of Service
    6. Note your **Merchant ID** (top-right corner after completion)
  </Accordion>

  <Accordion title="Step 2: Submit Your Android App for Approval">
    In the Google Pay & Wallet Console:

    1. Navigate to **Google Pay API** then **Integrations** then **Integrate with your Android app**
    2. Locate your Android application and click "Manage"
    3. Select your integration type (typically "Gateway")
    4. Upload screenshots of your TEST Google Pay integration
    5. Click "Save" then "Submit for approval"

    **Required Screenshots:**

    * Product/item selection showing Google Pay option
    * Cart or checkout view with payment options
    * Google Pay payment sheet with card selection
    * Confirmation or receipt screen
  </Accordion>

  <Accordion title="Step 3: Go Live">
    After Google approval (typically \~1 business day):

    1. Sign your APK with a **release key** (debug keys do not work in production)
    2. Update environment settings:
       * Kotlin: `environment = CheckoutEnvironment.PRODUCTION`
       * React Native: Use production API key
    3. Publish your app to Google Play Store
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Google Pay button does not appear">
    1. **Plugin not configured:** Verify `enableGooglePay: true` in `app.json` plugins
    2. **App not rebuilt:** Run `npx expo run:android` after adding the plugin
    3. **Environment mismatch:** Staging works without approval; production requires it
    4. **Payment method disabled:** Check `googlePay: true` in `allowedMethods`
  </Accordion>

  <Accordion title="PaymentRequest API is not supported error">
    1. **AndroidManifest missing queries:** Add all three Chromium intent queries
    2. **Native rebuild required:** Hot reload cannot apply permission changes
    3. **Device requirements:** User needs Google Play Services 25.18.30+ and WebView 137+
  </Accordion>
</AccordionGroup>