Google Pay Mobile

This guide is for mobile apps only. For web applications, Google Pay works automatically when enabled via the payment.fiat.allowedMethods.googlePay prop—no additional setup required. See Payment Methods for web configuration.

This guide covers how to enable Google Pay for token checkout and onramp flows in React Native and Android native (Kotlin) applications. Mobile apps require additional native configuration that web apps don’t need.

Overview

Crossmint’s mobile SDKs provide pre-built checkout components that support Google Pay out of the box. 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.

Mobile vs Web

Platform	Setup Required	Guide
Web (React, Next.js, etc.)	Enable via props only	Payment Methods
React Native (Expo)	Expo plugin + rebuild	This guide
React Native (Bare)	Manual Android config	This guide
Android Native (Kotlin)	AndroidManifest config	This guide

Supported Use Cases

Token purchases (buy tokens with fiat)
Stablecoin onramp (USDC, etc.)
NFT checkout

Mobile SDK Integration

React Native
Android Native (Kotlin)

Prerequisites

Before starting, ensure you have:

React Native project with Expo or bare workflow
Crossmint account with API keys (staging and/or production)
Android device or emulator with Google Play Services

Install Dependencies

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:

pnpm add react-native-webview@^13.15.0

Configure the Expo Plugin

Update your app.json to enable Google Pay:

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

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

Rebuild Your App

Hot reload cannot apply the permission changes. You must rebuild:

npx expo run:android

Or for bare React Native:

npx react-native run-android

Implement the Checkout Component

Use CrossmintEmbeddedCheckout for token purchases:

import {
  CrossmintEmbeddedCheckout,
  CrossmintProvider,
} from "@crossmint/client-sdk-react-native-ui";

export default function CheckoutScreen() {
  return (
    <CrossmintProvider apiKey="your_client_side_api_key">
      <CrossmintEmbeddedCheckout
        recipient={{
          walletAddress: "YOUR_WALLET_ADDRESS",
        }}
        payment={{
          crypto: { enabled: false },
          fiat: {
            enabled: true,
            allowedMethods: {
              card: true,
              applePay: false,
              googlePay: true,
            },
          },
        }}
        lineItems={{
          tokenLocator: "solana:TOKEN_ADDRESS",
          executionParameters: {
            mode: "exact-in",
            amount: "1",
            maxSlippageBps: "500",
          },
        }}
      />
    </CrossmintProvider>
  );
}

For staging/testing, use the XMEME test token:

tokenLocator: "solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu"

Customize Appearance (Optional)

Hide destination and email inputs for a cleaner UI:

<CrossmintEmbeddedCheckout
  // ... other props
  appearance={{
    rules: {
      DestinationInput: { display: "hidden" },
      ReceiptEmailInput: { display: "hidden" },
    },
    variables: {
      colors: {
        backgroundPrimary: "#000000",
        textPrimary: "#ffffff",
      },
    },
  }}
/>

The Kotlin SDK is currently in Beta. It provides the same checkout functionality with native Jetpack Compose components.

Prerequisites

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

Add the SDK Dependency

In your app-level build.gradle.kts:

dependencies {
    implementation("com.crossmint:crossmint-sdk-android:0.0.9")
}

Configure AndroidManifest.xml

Add the required query intents to enable Google Pay functionality:

<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>

Create Orders Server-Side

Security requirement: Order creation must happen on your backend to protect your API key.

curl --location 'https://staging.crossmint.com/api/2022-06-09/orders' \
--header 'x-api-key: YOUR_SERVER_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "recipient": {
        "walletAddress": "YOUR_WALLET_ADDRESS"
    },
    "payment": {
        "receiptEmail": "[email protected]",
        "method": "card"
    },
    "lineItems": {
        "tokenLocator": "solana:TOKEN_ADDRESS",
        "executionParameters": {
            "mode": "exact-in",
            "amount": "1"
        }
    }
}'

The response includes orderId and clientSecret needed for the checkout component.

Implement the Checkout Component

import com.crossmint.kotlin.checkout.CheckoutEnvironment
import com.crossmint.kotlin.checkout.CrossmintEmbeddedCheckout
import com.crossmint.kotlin.checkout.models.*

@Composable
fun CheckoutScreen(orderId: String, clientSecret: String) {
    CrossmintEmbeddedCheckout(
        orderId = orderId,
        clientSecret = clientSecret,
        payment = CheckoutPayment(
            crypto = CheckoutCryptoPayment(enabled = false),
            fiat = CheckoutFiatPayment(
                enabled = true,
                allowedMethods = CheckoutAllowedMethods(
                    googlePay = true,
                    applePay = false,
                    card = true
                )
            )
        ),
        appearance = CheckoutAppearance(
            rules = CheckoutAppearanceRules(
                destinationInput = CheckoutDestinationInputRule(display = "hidden"),
                receiptEmailInput = CheckoutReceiptEmailInputRule(display = "hidden")
            )
        ),
        environment = CheckoutEnvironment.STAGING,
        modifier = Modifier.fillMaxSize()
    )
}

Google Pay Production Approval

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

Step 1: Create Your Business Profile

Navigate to the Google Pay & Wallet Console
Select “Merchant” as your business type
Complete all business profile information
Navigate to Google Pay API and click “Get Started”
Accept the Google Pay API Terms of Service
Note your Merchant ID (top-right corner after completion)

Step 2: Submit Your Android App for Approval

In the Google Pay & Wallet Console:

Navigate to Google Pay API then Integrations then Integrate with your Android app
Locate your Android application and click “Manage”
Select your integration type (typically “Gateway”)
Upload screenshots of your TEST Google Pay integration
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

Step 3: Go Live

After Google approval (typically ~1 business day):

Sign your APK with a release key (debug keys don’t work in production)
Update environment settings:
- Kotlin: environment = CheckoutEnvironment.PRODUCTION
- React Native: Use production API key
Publish your app to Google Play Store

SDK Version Requirements

Component	Minimum Version
`@crossmint/client-sdk-react-native-ui`	Latest
`react-native-webview` (if installed separately)	13.15.0
`com.crossmint:crossmint-sdk-android`	Latest
Google Play Services (user device)	25.18.30

Troubleshooting

Google Pay button doesn't appear

Plugin not configured: Verify enableGooglePay: true in app.json plugins
App not rebuilt: Run npx expo run:android after adding the plugin
Environment mismatch: Staging works without approval; production requires it
Payment method disabled: Check googlePay: true in allowedMethods

PaymentRequest API is not supported error

AndroidManifest missing queries: Add all three Chromium intent queries
Native rebuild required: Hot reload cannot apply permission changes
Device requirements: User needs Google Play Services 25.18.30+ and WebView 137+

Order status stuck on undefined

Check that your API key is valid for the environment (staging vs production)
Verify the tokenLocator is correct and available
Ensure the quote hasn’t expired (quotes have time limits)

Token checkout errors

“Token purchase is only available in production”: Some tokens only work in production. Use the XMEME test token for staging: 7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu

Testing Guidance

Staging Environment
Production Environment

Use staging API keys from your Crossmint console
Google Pay functions immediately after proper configuration
Use XMEME test token for token testing
Test with real Google accounts and saved payment methods

Useful Resources

React Native Token Quickstart

Get started with token checkout in React Native

Google Pay & Wallet Console

Manage your Google Pay merchant account

Checkout Expo Demo

Example React Native Expo project with checkout

Kotlin Checkout SDK

Example Android Kotlin project with checkout

Introduction

Hosted (pop-up)

Embedded

Headless (API)

Advanced Guides

API Reference

Overview

Mobile vs Web

Supported Use Cases

Mobile SDK Integration

Prerequisites

Prerequisites

Google Pay Production Approval

SDK Version Requirements

Troubleshooting

Testing Guidance

Useful Resources

React Native Token Quickstart

Google Pay & Wallet Console

Checkout Expo Demo

Kotlin Checkout SDK

Introduction

Hosted (pop-up)

Embedded

Headless (API)

Advanced Guides

API Reference

​Overview

​Mobile vs Web

​Supported Use Cases

​Mobile SDK Integration

​Prerequisites

​Prerequisites

​Google Pay Production Approval

​SDK Version Requirements

​Troubleshooting

​Testing Guidance

​Useful Resources

React Native Token Quickstart

Google Pay & Wallet Console

Checkout Expo Demo

Kotlin Checkout SDK

Overview

Mobile vs Web

Supported Use Cases

Mobile SDK Integration

Prerequisites

Prerequisites

Google Pay Production Approval

SDK Version Requirements

Troubleshooting

Testing Guidance

Useful Resources