Accept in-app payments

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

The Payment Sheet is a customisable 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

The Payment Element allows you to accept multiple payment methods using a single integration. In this integration, you build a custom payment flow where you render the Payment Element, create the PaymentIntent, and confirm the payment in your app. To confirm the payment on the server instead, see Finalise payments on the server.

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.

You also need to set your publishable key so that the SDK can make API calls to Stripe. To get started quickly, you can hardcode this 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
PaymentConfiguration.init(context, publishableKey = "pk_test_GvF3BSyx8RSXMK5yAFhqEd3H")

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.

Collect payment details Client-side

We offer two styles of integration.

Initialise the PaymentSheet

Initialise the PaymentSheet and pass in a CreateIntentCallback. Leave the implementations empty for now.

class MyCheckoutActivity : AppCompatActivity() {

 private lateinit var paymentSheet: PaymentSheet

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 // ...

 paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult)
 .createIntentCallback { confirmationToken ->
 TODO() // You'll implement this later
 }
 .build(this)
 }

 fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 // You'll implement this later
 }
}

Present the PaymentSheet

Next, present the PaymentSheet by calling presentWithIntentConfiguration() and pass in an IntentConfiguration. The IntentConfiguration contains details about the specific PaymentIntent, such as the amount and currency.

class MyCheckoutActivity : AppCompatActivity() {

 // ...

 private fun handleCheckoutButtonPressed() {
 val intentConfig = PaymentSheet.IntentConfiguration(
 mode = PaymentSheet.IntentConfiguration.Mode.Payment(
 amount = 1099,
 currency = "usd",
 ),
 // Other configuration options...
 )

 paymentSheet.presentWithIntentConfiguration(
 intentConfiguration = intentConfig,
 // Optional configuration - See the "Customize the sheet" section in this guide
 configuration = PaymentSheet.Configuration.Builder(
 merchantDisplayName = "Example Inc.",
 ).build()
 )
 }
}

Confirm the Intent

When your customer taps the Pay button in PaymentSheet, it calls the CreateIntentCallback you passed above with a ConfirmationToken that represents your customer’s payment details and preferences.

Implement this method to send a request to your server with confirmationToken.id. Your server creates a PaymentIntent and returns its client secret.

When you receive the response, return the response’s client secret or an error. The PaymentSheet confirms the PaymentIntent using the client secret, or displays the error in its UI.

class MyCheckoutActivity : AppCompatActivity() {

 private lateinit var paymentSheet: PaymentSheet

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 // ...

 paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult)
 .createIntentCallback { confirmationToken ->
 // Make a request to your server to create a PaymentIntent and return its client secret
 val networkResult = myNetworkClient.createIntent(
 confirmationTokenId = confirmationToken.id,
 )
 if (networkResult.isSuccess) {
 CreateIntentResult.Success(networkResult.clientSecret)
 } else {
 CreateIntentResult.Failure(networkResult.exception)
 }
 }
 .build(this)
 }

 fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 // You'll implement this later
 }
}

After your customer completes payment, the sheet closes, and PaymentSheet invokes the PaymentSheetResultCallback you provide with a PaymentSheetResult.

class MyCheckoutActivity : AppCompatActivity() {

 // ...

 fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
 when(paymentSheetResult) {
 is PaymentSheetResult.Canceled -> {
 // Customer canceled - you should probably do nothing.
 }
 is PaymentSheetResult.Failed -> {
 print("Error: ${paymentSheetResult.error}")
 // PaymentSheet encountered an unrecoverable error. You can display the error to the user, log it, and so on
 }
 is PaymentSheetResult.Completed -> {
 // Display, for example, an order confirmation screen
 print("Completed")
 }
 }
 }
}

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_Ou1w6LVt3zmVipDVJsvMeQsc')

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.

Optional Enable saved cards Server-side Client-side

Optional Allow delayed payment methods Client-side

Optional Enable Google Pay

Optional Enable card scanning

Optional Customize the sheet

Optional Enable CVC recollection on confirmation