Save payment details during an in-app payment

Save payment details during a payment in your mobile app.

Accounts v2 API support

The Payment Sheet doesn’t support customer-configured Accounts. It only supports Customer objects.

iOS

Android

React Native

Use the Payment Intents API to save payment details from a purchase. There are several use cases:

• Charge a customer for an e-commerce order and store the details for future purchases.
• Initiate the first payment of a series of recurring payments.
• Charge a deposit and store the details to charge the full amount later.

Card-present transactions

Card-present transactions, such as payments through Stripe Terminal, use a different process for saving the payment method. For details, see the Terminal documentation.

Compliance

You’re responsible for your compliance with all applicable laws, regulations, and network rules when saving a customer’s payment details for future use, such as displaying a customer’s payment method to them in the checkout flow for a future purchase or charging them when they’re not actively using your website or app. Before saving or charging a customer’s payment method, make sure you:

• Add terms to your website or app that state how you plan to save payment method details, such as:
• The customer’s agreement allowing you to initiate a payment or a series of payments on their behalf for specified transactions.
• The anticipated timing and frequency of payments (for example, if the charges are for scheduled installments, subscription payments, or unscheduled top-ups).
• How you determine the payment amount.
• Your cancellation policy, if the payment method is for a subscription service.
• Use a saved payment method for only the purpose stated in your terms.
• Collect explicit consent from the customer for this specific use. For example, include a "Save my payment method for future checkbox.
• Keep a record of your customer’s written agreement to your terms.

Set up Stripe Server-side Client-side

First, you need a Stripe account. Register now.

Server-side

This integration requires endpoints on your server that talk to the Stripe API. Use the official libraries for access to the Stripe API from your server:

Command Line

Select a language

Ruby

Python

PHP

Java

Node.js

Go

.NET

No results

# Available as a gem
sudo gem install stripe

Gemfile

Select a language

Ruby

Python

PHP

Java

Node.js

Go

.NET

No results

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

Client-side

The Stripe Android SDK is open source and fully documented.

To install the SDK, add stripe-android to the dependencies block of your app/build.gradle file:

build.gradle.kts

Select a language

Kotlin

Groovy

No results

plugins {
 id("com.android.application")
}

android { ... }

dependencies {
 // ...

 // Stripe Android SDK
 implementation("com.stripe:stripe-android:23.20.0")
 // Include the financial connections SDK to support US bank account as a payment method
 implementation("com.stripe:financial-connections:23.20.0")
}

Note

For details on the latest SDK release and past versions, see the Releases page on GitHub. To receive notifications when a new release is published, watch releases for the repository.

Enable payment methods

Card payments are enabled by default. View your payment methods settings to enable more payment methods you want to support.

Add an endpoint Server-side

Note

To display the PaymentSheet before you create a PaymentIntent, see Collect payment details before creating an Intent.

This integration uses three Stripe API objects:

1. PaymentIntent: Stripe uses this to represent your intent to collect payment from a customer, tracking your charge attempts and payment state changes throughout the process.
2. A customer-configured Account or a Customer object: To set up a payment method for future payments, you must attach it to a customer. Create an object to represent your customer when they create an account with your business. If your customer makes a payment as a guest, you can create an Account or Customer object before payment and associate it with your own internal representation of the customer’s account later.
3. CustomerSession: Information on the object that represents your customer is sensitive, and can’t be retrieved directly from an app. A CustomerSession grants the SDK temporary scoped access to the Account or Customer and provides additional configuration options. See a complete list of configuration options.

For security reasons, your app can’t create these objects. Instead, add an endpoint on your server that:

1. Retrieves the Account or Customer , or creates a new one.
2. Creates a CustomerSession for the Account or Customer .
3. Creates a PaymentIntent with the amount , currency , setup_future_usage , and either the customer_account or the customer .
4. Returns the PaymentIntent ’s client secret , the CustomerSession ’s client _ secret , the ID of the Account or Customer , and your publishable key to your app.

Set the same Account or Customer on the PaymentIntent that you set on the CustomerSession.

Note

The mobile Payment Element only supports setup_future_usage with cards and US bank accounts.

The payment methods shown to customers during the checkout process are also included on the PaymentIntent. You can let Stripe pull payment methods from your Dashboard settings or you can list them manually. Regardless of the option you choose, know that the currency passed in the PaymentIntent filters the payment methods shown to the customer. For example, if you pass eur on the PaymentIntent and have the related setting enabled in the Dashboard, the related setting won’t be shown to the customer because the related setting doesn’t support eur payments.

Unless your integration requires a code-based option for offering payment methods, Stripe recommends the automated option. This is because Stripe evaluates the currency, payment method restrictions, and other parameters to determine the list of supported payment methods. Payment methods that increase conversion and that are most relevant to the currency and customer’s location are prioritized.

You can manage payment methods from the Dashboard. Stripe creates the PaymentIntent using eligible payment methods you’ve configured, based on factors such as the transaction’s amount, currency, and payment flow. If you don’t want to use the Dashboard, or if you want to specify the allowed payment methods manually, you can use the allowed_payment_method_types parameter.

Command Line

Select a language

curl

Ruby

Python

PHP

Java

Node.js

Go

.NET

No results

Collect payment details Client-side

Before displaying the mobile Payment Element, your checkout page should:

• Show the products being purchased and the total amount
• Collect any required shipping information using the Address Element
• Include a checkout button to present Stripe’s UI

Initialize a PaymentSheet instance inside onCreate of your checkout Activity, passing a method to handle the result.

import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
 val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult).build() }
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 // implemented in the next steps
}

Next, fetch the Payment Intent client secret, Customer Session client secret, Customer ID, and publishable key from the endpoint you created in the previous step. Set the publishable key using PaymentConfiguration and store the others for use when you present the PaymentSheet.

import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
 val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
 val context = LocalContext.current
 var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
 var paymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

 LaunchedEffect(context) {
 // Make a request to your own server and retrieve payment configurations
 val networkResult = ...
 if (networkResult.isSuccess) {
 paymentIntentClientSecret = networkResult.paymentIntent
 customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
 id = networkResult.customer,
 clientSecret = networkResult.customerSessionClientSecret
 )
 PaymentConfiguration.init(context, networkResult.publishableKey)
 }
 }
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 // implemented in the next steps
}

When the customer taps your checkout button, call presentWithPaymentIntent to present the payment sheet. After the customer completes the payment, the sheet dismisses and the PaymentSheetResultCallback is called with a PaymentSheetResult.

import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
 val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
 val context = LocalContext.current
 var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
 var paymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

 LaunchedEffect(context) {
 // Make a request to your own server and retrieve payment configurations
 val networkResult = ...
 if (networkResult.isSuccess) {
 paymentIntentClientSecret = networkResult.paymentIntent
 customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
 id = networkResult.customer,
 clientSecret = networkResult.customerSessionClientSecret
 )
 PaymentConfiguration.init(context, networkResult.publishableKey)
 }
 }

 Button(
 onClick = {
 val currentConfig = customerConfig
 val currentClientSecret = paymentIntentClientSecret

 if (currentConfig != null && currentClientSecret != null) {
 presentPaymentSheet(paymentSheet, currentConfig, currentClientSecret)
 }
 }
 ) {
 Text("Checkout")
 }
}

private fun presentPaymentSheet(
 paymentSheet: PaymentSheet,
 customerConfig: PaymentSheet.CustomerConfiguration,
 paymentIntentClientSecret: String
) {
 paymentSheet.presentWithPaymentIntent(
 paymentIntentClientSecret,
 PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
 .customer(customerConfig)
 // Set `allowsDelayedPaymentMethods` to true if your business handles
 // delayed notification payment methods like US bank accounts.
 .allowsDelayedPaymentMethods(true)
 .build()
 )
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 when(paymentSheetResult) {
 is PaymentSheetResult.Canceled -> {
 print("Canceled")
 }
 is PaymentSheetResult.Failed -> {
 print("Error: ${paymentSheetResult.error}")
 }
 is PaymentSheetResult.Completed -> {
 // Display for example, an order confirmation screen
 print("Completed")
 }
 }
}

Setting allowsDelayedPaymentMethods to true allows delayed notification payment methods like US bank accounts. For these payment methods, the final payment status isn’t known when the PaymentSheet completes, and instead succeeds or fails later. If you support these types of payment methods, inform the customer their order is confirmed and only fulfill their order (for example, ship their product) when the payment is successful.

Handle post-payment events Server-side

Stripe sends a payment_intent.succeeded event when the payment completes. Use the Dashboard webhook tool or follow the webhook guide to receive these events and run actions, such as sending an order confirmation email to your customer, logging the sale in a database, or starting a shipping workflow.

Listen for these events rather than waiting on a callback from the client. On the client, the customer could close the browser window or quit the app before the callback executes, and malicious clients could manipulate the response. Setting up your integration to listen for asynchronous events is what enables you to accept different types of payment methods with a single integration.

In addition to handling the payment_intent.succeeded event, we recommend handling these other events when collecting payments with the Payment Element:

Charge the saved Payment Method later Server-side

To find a payment method to charge, list the payment methods associated with your customer. This example lists cards, but you can list any supported type.

Use the Accounts v2 API to represent customers

The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a preview version in your code.

To join the Accounts v2 preview, go to Account previews and features in your Dashboard and enable Reusable payment methods for Global Payouts.

For most use cases, we recommend modeling your customers as customer-configured Account objects instead of using Customer objects.

Command Line

Select a language

cURL

Stripe CLI

Ruby

Python

PHP

Java

Node.js

Go

.NET

No results

When you’re ready to charge your customer off-session, use the ID of the Customer or customer-configured Account and the PaymentMethod ID to create a PaymentIntent with the amount and currency of the payment. Set a few other parameters to make the off-session payment:

• Set off_session to true to indicate that the customer isn’t in your checkout flow to respond to any authentication requests. If, during your checkout flow, a partner (such as a card issuer or bank) requests authentication, Stripe requests exemptions using customer information from a previous on-session transaction. If the conditions for exemption aren’t met, the PaymentIntent might throw an error.
• Set confirm to true to trigger confirmation immediately when the PaymentIntent is created.
• Set payment_method to the PaymentMethod ’s ID.
• Depending on how you represent customers in your integration, set either customer_account to the ID of the customer-configured Account or customer to the ID of the Customer .

Command Line

Select a language

cURL

Stripe CLI

Ruby

Python

PHP

Java

Node.js

Go

.NET

No results

Test the integration

Optional Enable Google Pay

Optional Customize the sheet

Optional Complete payment in your UI