Accept in-app payments

Build a customized payments integration in your iOS, Android, or React Native app using the Payment Sheet.

The Payment Sheet is a customizable component that displays a list of payment methods and collects payment details in your app using a bottom sheet.

Accounts v2 API support

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

iOS

Android

React Native

A PaymentIntent flow allows you to create a charge in your app by rendering the Payment Sheet, creating a PaymentIntent, then confirming a charge in your app.

The Payment Sheet can show the customer’s previously selected payment if it’s saved on their device. When confirming the charge, you can optionally save the payment method to the device. This doesn’t update their default payment method.

Set up Stripe Server-side Client-side

Server-side

This integration requires endpoints on your server that talk to the Stripe API. Use our 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 iOS SDK is open source, fully documented, and compatible with apps supporting iOS 13 or above.

To install the SDK, follow these steps:

1. In Xcode, select File > Add Package Dependencies… and enter https://github. the relevant part of the product as the repository URL.
2. Select the latest version number from our releases page .
3. Add the StripePaymentSheet product to the target of your app .

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.

You also need to set your publishable key so that the SDK can make API calls to Stripe. To get started, you can hardcode the publishable key on the client while you’re integrating, but fetch the publishable key from your server in production.

// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
STPAPIClient.shared.publishableKey = "pk_test_TYooMQauvdEDq54NiTphI7jx"

Enable payment methods

View your payment methods settings and enable the payment methods you want to support. You need at least one payment method enabled to create a PaymentIntent.

By default, Stripe enables cards and other prevalent payment methods that can help you reach more customers, but we recommend turning on additional payment methods that are relevant for your business and customers. See Payment method support for product and payment method support, and our pricing page for fees.

Set up a return URL Client-side

The customer might navigate away from your app to authenticate (for example, in Safari or their banking app). To allow them to automatically return to your app after authenticating, configure a custom URL scheme and set up your app delegate to forward the URL to the SDK. Stripe doesn’t support universal links.

SceneDelegate.swift

Swift

// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
 guard let url = URLContexts.first?.url else {
 return
 }
 let stripeHandled = StripeAPI.handleURLCallback(with: url)
 if (!stripeHandled) {
 // This was not a Stripe url – handle the URL normally as you would
 }
}

Additionally, set the returnURL on your PaymentSheet.Configuration object to the URL for your app.

var configuration = PaymentSheet.Configuration()
configuration.returnURL = "your-app://stripe-redirect"

Collect payment details Client-side

We offer two styles of integration. Choose one to continue.

Initialize PaymentSheet

When you’re ready to accept a payment (for example, when a customer taps your checkout button), initialize the PaymentSheet with a PaymentSheet.Configuration and a PaymentSheet.IntentConfiguration. The Configuration object contains the general configuration for the PaymentSheet that typically doesn’t change between payments, such as the returnURL. The IntentConfiguration object contains details about the specific payment, such as the amount and currency, and a confirmationTokenConfirmHandler callback—for now, leave its implementation empty.

import StripePaymentSheet

class MyCheckoutVC: UIViewController {
 func didTapCheckoutButton() {
 let intentConfig = PaymentSheet.IntentConfiguration(
 mode: .payment(amount: 1099, currency: "USD", )
 ) { [weak self] confirmationToken in
 try await self?.handleConfirmationToken(confirmationToken)
 }
 var configuration = PaymentSheet.Configuration()
 configuration.returnURL = "your-app://stripe-redirect" // Use the return url you set up in the previous step
 let paymentSheet = PaymentSheet(intentConfiguration: intentConfig, configuration: configuration)
 }

 func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String {
 // ...explained later
 }
}

Present PaymentSheet

Next, present the PaymentSheet. The present method takes a completion block that’s called when the customer finishes paying and dismisses the sheet. Implement the completion block to handle the result (for example, by showing a receipt or confirmation screen in the .completed case.)

class MyCheckoutVC: UIViewController {
 func didTapCheckoutButton() {
 // ...
 paymentSheet.present(from: self) { result in
 switch result {
 case .completed:
 // Payment completed - show a confirmation screen.
 case .failed(let error):
 print(error)
 // PaymentSheet encountered an unrecoverable error. You can display the error to the user, log it, and so on
 case .canceled:
 // Customer canceled - you should probably do nothing.
 }
 }
 }
}

Confirm the payment

When the customer taps the Pay button in the PaymentSheet, it calls the callback you passed to PaymentSheet.IntentConfiguration with an STPConfirmationToken object representing the customer’s payment details and preferences.

Implement this callback to send a request to your server. Your server creates a PaymentIntent and returns its client secret.

When the request returns, return your server response’s client secret or throw an error. The PaymentSheet confirms the PaymentIntent using the client secret or displays the localized error message in its UI (either errorDescription or localizedDescription).

class MyCheckoutVC: UIViewController {
 // ...

 func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String {
 // Make a request to your own server. Pass confirmationToken.stripeId if using server-side confirmation.
 // Return the client secret or throw an error.
 return try await MyAPIClient.shared.createIntent(confirmationTokenId: confirmationToken.stripeId)
 }
}

Create a PaymentIntent Server-side

On your server, create a PaymentIntent with an amount and currency. You can manage payment methods from the Dashboard. Stripe handles the return of eligible payment methods based on factors such as the transaction’s amount, currency, and payment flow. To prevent malicious customers from choosing their own prices, always decide how much to charge on the server-side (a trusted environment) and not the client.

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

If the call succeeds, return the PaymentIntent client secret. If the call fails, handle the error and return an error message with a brief explanation for your customer.

Note

Verify that all IntentConfiguration properties match your PaymentIntent (for example, setup_future_usage, amount, and currency).

main.rb

Select a language

Ruby

Python

PHP

Node.js

Java

Go

.NET

No results

require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('sk_test_BQokikJOvBiI2HlWgH4olfQ2')

post '/create-intent' do
 data = JSON.parse request.body.read
 params = {
 amount: 1099,
 currency: 'usd',
 automatic_payment_methods: {enabled: true},
 }
 begin
 intent = client.v1.payment_intents.create(params)
 {client_secret: intent.client_secret}.to_json
 rescue Stripe::StripeError => e
 {error: e.error.message}.to_json
 end
end

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:

Test the integration

See Testing for additional information to test your integration.

Enable card scanning

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 Enable saved cards Server-side Client-side

Optional Allow delayed payment methods Client-side

Optional Enable Apple Pay

Optional Customize the sheet

Optional Enable CVC recollection on confirmation