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 React Native SDK is open source and fully documented. Internally, it uses the native iOS and Android SDKs. To install Stripe’s React Native SDK, run one of the following commands in your project’s directory (depending on which package manager you use):

Command Line

yarn add @stripe/stripe-react-native

Next, install some other necessary dependencies:

• For iOS, go to the ios directory and run pod install to ensure that you also install the required native dependencies.
• For Android, there are no more dependencies to install.

Note

We recommend following the official TypeScript guide to add TypeScript support.

Stripe initialization

To initialize Stripe in your React Native app, either wrap your payment screen with the StripeProvider component, or use the initStripe initialization method. Only the API publishable key in publishableKey is required. The following example shows how to initialize Stripe using the StripeProvider component.

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 (
 <StripeProvider
 publishableKey={publishableKey}
 merchantIdentifier="merchant.identifier" // required for Apple Pay
 urlScheme="your-url-scheme" // required for 3D Secure and bank redirects
 >
 {/* Your app code here */}
 </StripeProvider>
 );
}

Note

Use your API test keys while you test and develop, and your live mode keys when you publish your app.

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
• Include a checkout button to present Stripe’s UI

In the checkout of your app, make a network request to the backend endpoint you created in the previous step and call initPaymentSheet from the useStripe hook.

export default function CheckoutScreen() {
 const { initPaymentSheet, presentPaymentSheet } = useStripe();
 const [loading, setLoading] = useState(false);

 const fetchPaymentSheetParams = async () => {
 const response = await fetch(`${API_URL}/payment-sheet`, {
 method: 'POST',
 headers: {
 'Content-Type': 'application/json',
 },
 });
 const { paymentIntent, ephemeralKey, customer_account } = await response.json();

 return {
 paymentIntent,
 ephemeralKey,
 customer_account,
 };
 };

 const initializePaymentSheet = async () => {
 const {
 paymentIntent,
 ephemeralKey,
 customer_account,
 } = await fetchPaymentSheetParams();

 const { error } = await initPaymentSheet({
 merchantDisplayName: "Example, Inc.",
 customerAccountId: customer_account,
 customerEphemeralKeySecret: ephemeralKey,
 paymentIntentClientSecret: paymentIntent,
 // Set `allowsDelayedPaymentMethods` to true if your business accepts payment
 // methods that complete payment after a delay, like SEPA Debit and Sofort.
 allowsDelayedPaymentMethods: true,
 defaultBillingDetails: {
 name: 'Jane Doe',
 }
 });
 if (!error) {
 setLoading(true);
 }
 };

 const openPaymentSheet = async () => {
 // see below
 };

 useEffect(() => {
 initializePaymentSheet();
 }, []);

 return (
 <Screen>
 <Button
 variant="primary"
 disabled={!loading}
 title="Checkout"
 onPress={openPaymentSheet}
 />
 </Screen>
 );
}

When your customer taps the Checkout button, call presentPaymentSheet() to open the sheet. After the customer completes the payment, the sheet is dismissed and the promise resolves with an optional StripeError<PaymentSheetError>.

export default function CheckoutScreen() {
 // continued from above

 const openPaymentSheet = async () => {
 const { error } = await presentPaymentSheet();

 if (error) {
 Alert.alert(`Error code: ${error.code}`, error.message);
 } else {
 Alert.alert('Success', 'Your order is confirmed!');
 }
 };

 return (
 <Screen>
 <Button
 variant="primary"
 disabled={!loading}
 title="Checkout"
 onPress={openPaymentSheet}
 />
 </Screen>
 );
}

If there is no error, inform the customer they’re done (for example, by displaying an order confirmation screen).

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.

Set up a return URL (iOS only) Client-side

When a customer exits your app (for example to authenticate in Safari or their banking app), provide a way for them to automatically return to your app. Many payment method types require a return URL. If you don’t provide one, we can’t present payment methods that require a return URL to your users, even if you’ve enabled them.

To provide a return URL:

1. Register a custom URL. Universal links aren’t supported.
2. Configure your custom URL.
3. Set up your root component to forward the URL to the Stripe SDK as shown below.

Note

If you’re using Expo, set your scheme in the app.json file.

App.tsx

import { useEffect, useCallback } from 'react';
import { Linking, View } from 'react-native';
import { useStripe } from '@stripe/stripe-react-native';

export default function MyApp() {
 const { handleURLCallback } = useStripe();

 const handleDeepLink = useCallback(
 async (url: string | null) => {
 if (url) {
 const stripeHandled = await handleURLCallback(url);
 if (stripeHandled) {
 // This was a Stripe URL - you can return or add extra handling here as you see fit
 } else {
 // This was NOT a Stripe URL – handle as you normally would
 }
 }
 },
 [handleURLCallback]
 );

 useEffect(() => {
 const getUrlAsync = async () => {
 const initialUrl = await Linking.getInitialURL();
 handleDeepLink(initialUrl);
 };

 getUrlAsync();

 const deepLinkListener = Linking.addEventListener(
 'url',
 (event: { url: string }) => {
 handleDeepLink(event.url);
 }
 );

 return () => deepLinkListener.remove();
 }, [handleDeepLink]);

 return (
 <View>
 <AwesomeAppComponent />
 </View>
 );
}

Additionally, set the returnURL when you call the initPaymentSheet method:

await initPaymentSheet({
 ...
 returnURL: 'your-app://stripe-redirect',
 ...
});

For more information on native URL schemes, refer to the Android and iOS docs.

Handle post-payment events

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

Optional Enable Google Pay

Enable card scanning Client-side

Note

Enabling card scanning is required for Apple’s iOS app review process. Card scanning is not required for Android’s app review process, but we recommend enabling it.

iOS

To enable card scanning support for iOS, set the NSCameraUsageDescription ( Privacy - Camera Usage Description) in the Info.plist of your application, and provide a reason for accessing the camera (for example, “To scan cards”).

Optional Android

To enable card scanning support, request production access to the Google Pay API from the Google Pay and Wallet Console.

• If you’ve enabled Google Pay, the card scanning feature is automatically available in our UI on eligible devices. To learn more about eligible devices, see the Google Pay API constraints
• Important: The card scanning feature only appears in builds signed with the same signing key registered in the Google Pay & Wallet Console . Test or debug builds using different signing keys (for example, builds distributed through Firebase App Tester) won’t show the Scan card option. To test card scanning in pre-release builds, you must either:
• Sign your test builds with your production signing key
• Add your test signing key fingerprint to the Google Pay and Wallet Console

If your app doesn’t support Google Pay, you can use the Stripe card scanner.

Public preview

The Stripe card scanner is in public preview.

To enable card scanning support, add stripecardscan to the dependencies block of your app/build.gradle file:

build.gradle

Select a language

Groovy

Kotlin

No results

implementation 'com.stripe:stripecardscan:23.20.0'

Optional Customize the sheet Client-side

Optional Complete payment in your UI