Skip to content
Create account
 or
Sign in
The Stripe Docs logo
/
Create account
Sign in
OverviewUpgrade your integration
Online payments
OverviewFind your use caseManaged Payments
Payment methods
Payment interfaces
Payment scenarios
In-person payments
Beyond payments

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.

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 Finalize 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
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Available as a gem
sudo gem install stripe
Gemfile
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
Kotlin
Groovy
No results
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

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

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

Collect payment details
Client-side

We offer two styles of integration.

PaymentSheet PaymentSheet.FlowController
PaymentSheet
PaymentSheet.FlowController
Displays a sheet to collect payment details and complete the payment. The button label is Pay and the amount. Clicking the button completes the payment. Displays a sheet to only collect payment details. The button label is Continue. Clicking it returns the customer to your app, where your own button completes the payment.

Initialize the PaymentSheet

Initialize the PaymentSheet and pass in a CreateIntentCallback. For now, leave the implementation empty.

class MyCheckoutActivity : AppCompatActivity() {

  private lateinit var paymentSheet: PaymentSheet

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

    paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult)
      .createIntentCallback { _, _ ->
        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 passing in an IntentConfiguration. The IntentConfiguration contains details about the specific PaymentIntent, like 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 the customer taps the Pay button in PaymentSheet, it calls the CreateIntentCallback you passed above with a PaymentMethod object representing the customer’s payment details.

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

When the response returns, 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 { _, _ ->
        // Make a request to your server to create a PaymentIntent and return its client secret
        val networkResult = myNetworkClient.createIntent(
        )
        if (networkResult.isSuccess) {
            CreateIntentResult.Success(networkResult.clientSecret)
        } else {
            CreateIntentResult.Failure(networkResult.exception)
        }
      }
      .build(this)
  }

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

After the customer completes the payment, the sheet closes and the PaymentSheetResultCallback is called 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, etc.
      }
      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.

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
Ruby
Python
PHP
Node.js
Java
Go
.NET
No results
require 'stripe'
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/create-intent' do
  data = JSON.parse request.body.read
  params = {
    amount: 1099,
    currency: 'usd',
    # In the latest version of the API, specifying the `automatic_payment_methods` parameter is optional because Stripe enables its functionality by default.
    automatic_payment_methods: {enabled: true},
  }
  begin
    intent = Stripe::PaymentIntent.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:

EventDescriptionAction
payment_intent.succeededSent when a customer successfully completes a payment.Send the customer an order confirmation and fulfill their order.
payment_intent.processingSent when a customer successfully initiates a payment, but the payment has yet to complete. This event is most commonly sent when the customer initiates a bank debit. It’s followed by either a payment_intent.succeeded or payment_intent.payment_failed event in the future.Send the customer an order confirmation that indicates their payment is pending. For digital goods, you might want to fulfill the order before waiting for payment to complete.
payment_intent.payment_failedSent when a customer attempts a payment, but the payment fails.If a payment transitions from processing to payment_failed, offer the customer another attempt to pay.

Test the integration

Card numberScenarioHow to test
The card payment succeeds and doesn’t require authentication.Fill out the credit card form using the credit card number with any expiration, CVC, and postal code.
The card payment requires authentication.Fill out the credit card form using the credit card number with any expiration, CVC, and postal code.
The card is declined with a decline code like insufficient_funds.Fill out the credit card form using the credit card number with any expiration, CVC, and postal code.
The UnionPay card has a variable length of 13-19 digits.Fill out the credit card form using the credit card number with any expiration, CVC, and postal code.

See Testing for additional information to test your integration.

OptionalEnable saved cards
Server-side
Client-side

PaymentSheet can allow the customer to save their card and can include the customer’s saved cards in available payment methods. The customer must have an associated Customer object on your server. To enable a checkbox that allows the customer to save their card, create an Ephemeral Key associated with the Customer.

app.js
const stripe = require("stripe")(
"sk_test_BQokikJOvBiI2HlWgH4olfQ2"
);
const express = require('express');
const app = express();

app.set('trust proxy', true);
app.use(express.json());

app.post('/payment-sheet', async (req, res) => {
  // Use an existing Customer ID if this is a returning customer.
  const customer = await stripe.customers.create();
  const ephemeralKey = await stripe.ephemeralKeys.create(
    {customer: customer.id},
    {apiVersion: '2020-08-27'}
  );

  res.json({
    ephemeralKey: ephemeralKey.secret,
    customer: customer.id,
  });
});

Next, present PaymentSheet with the Customer’s ID and the Ephemeral Key’s client secret.

val configuration = PaymentSheet.Configuration.Builder("Merchant, Inc.")
  .customer(PaymentSheet.CustomerConfiguration(
    id = customerId,
    ephemeralKeySecret = customerEphemeralKeySecret,
  ))
  .build()

paymentSheet.presentWithIntentConfiguration(
  intentConfiguration = // ... ,
  configuration = configuration,
)

OptionalAllow delayed payment methods
Client-side

Delayed payment methods don’t guarantee that you’ll receive funds from your customer at the end of checkout, either because they take time to settle (for example, US Bank Accounts, SEPA Debit, iDEAL, Bancontact, and Sofort) or because they require customer action to complete (for example, OXXO, Konbini, and Boleto).

By default, PaymentSheet doesn’t display delayed payment methods. To include the delayed payment methods that PaymentSheet supports, set allowsDelayedPaymentMethods to true in your PaymentSheet.Configuration.

val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Powdur")
  .allowsDelayedPaymentMethods(true)
  .build()

If the customer successfully uses a delayed payment method in a PaymentSheet, the payment result returned is PaymentSheetResult.Completed.

OptionalEnable Google Pay

Note

If your checkout screen has a dedicated Google Pay button, follow the Google Pay guide. You can use Embedded Payment Element to handle other payment method types.

Set up your integration

To use Google Pay, first enable the Google Pay API by adding the following to the <application> tag of your AndroidManifest.xml:

AndroidManifest.xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>

For more details, see Google Pay’s Set up Google Pay API for Android.

Add Google Pay

To add Google Pay to your integration, pass a PaymentSheet.GooglePayConfiguration with your Google Pay environment (production or test) and the country code of your business when initializing PaymentSheet.Configuration.

Kotlin
Java
No results
val googlePayConfiguration = PaymentSheet.GooglePayConfiguration(
  environment = PaymentSheet.GooglePayConfiguration.Environment.Test,
  countryCode = "US",
  currencyCode = "USD" // Required for Setup Intents, optional for Payment Intents
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
  .googlePay(googlePayConfiguration)
  .build()

Test Google Pay

Google allows you to make test payments through their Test card suite. The test suite supports using stripe test cards.

You can test Google Pay using a physical Android device. Make sure you have a device in a country where google pay is supported and log in to a Google account on your test device with a real card saved to Google Wallet.

OptionalEnable card scanning

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

build.gradle
Groovy
Kotlin
No results
apply plugin: 'com.android.application'

android { ... }

dependencies {
  // ...

  // StripeCardScan
  implementation 'com.stripe:stripecardscan:21.26.1'
}

OptionalCustomize the sheet

All customization is configured using the PaymentSheet.Configuration object.

Appearance

Customize colors, fonts, and more to match the look and feel of your app by using the appearance API.

Payment method layout

Configure the layout of payment methods in the sheet using paymentMethodLayout. You can display them horizontally, vertically, or let Stripe optimize the layout automatically.

Kotlin
Java
No results
PaymentSheet.Configuration.Builder("Example, Inc.")
  .paymentMethodLayout(PaymentSheet.PaymentMethodLayout.Automatic)
  .build()

Collect users addresses

Collect local and international shipping or billing addresses from your customers using the Address Element.

Business display name

Specify a customer-facing business name by setting merchantDisplayName. By default, this is your app’s name.

Kotlin
Java
No results
PaymentSheet.Configuration.Builder(
  merchantDisplayName = "My app, Inc."
).build()

Dark mode

By default, PaymentSheet automatically adapts to the user’s system-wide appearance settings (light and dark mode). You can change this by setting light or dark mode on your app:

Kotlin
Java
No results
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)

Default billing details

To set default values for billing details collected in the payment sheet, configure the defaultBillingDetails property. The PaymentSheet pre-populates its fields with the values that you provide.

Kotlin
Java
No results
val address = PaymentSheet.Address(country = "US")
val billingDetails = PaymentSheet.BillingDetails(
  address = address,
  email = "foo@bar.com"
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .build()

Configure collection of billing details

Use BillingDetailsCollectionConfiguration to specify how you want to collect billing details in the PaymentSheet.

You can collect your customer’s name, email, phone number, and address.

If you want to attach default billing details to the PaymentMethod object even when those fields aren’t collected in the UI, set billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod to true.

Kotlin
Java
No results
val billingDetails = PaymentSheet.BillingDetails(
  email = "foo@bar.com"
)
val billingDetailsCollectionConfiguration = BillingDetailsCollectionConfiguration(
  attachDefaultsToPaymentMethod = true,
  name = BillingDetailsCollectionConfiguration.CollectionMode.Always,
  email = BillingDetailsCollectionConfiguration.CollectionMode.Never,
  address = BillingDetailsCollectionConfiguration.AddressCollectionMode.Full,
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .billingDetailsCollectionConfiguration(billingDetailsCollectionConfiguration)
  .build()

Note

Consult with your legal counsel regarding laws that apply to collecting information. Only collect phone numbers if you need them for the transaction.

OptionalEnable CVC recollection on confirmation

The following instructions for re-collecting the CVC of a saved card during PaymentIntent confirmation assume that your integration includes the following:

  • Collection of payment details before creating a PaymentIntent
  • Client-side confirmation

Update the intent configuration

PaymentSheet.IntentConfiguration accepts an additional optional parameter that controls when to re-collect CVC for a saved card.

internal class MyCheckoutActivity : AppCompatActivity() {

    private val viewModel by viewModels<MyCheckoutViewModel>()

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

        setContent {
            val paymentSheet = PaymentSheet.Builder(
                viewModel::onPaymentSheetResult
            )
            .createIntentCallback(viewModel::createIntentCallback)
            .build()

            paymentSheet.presentWithIntentConfiguration(
                PaymentSheet.IntentConfiguration(
                    mode = Mode.Payment(amount = 1000, currency = "USD")
                    paymentMethodTypes = paymentMethodTypes,
                    paymentMethodConfigurationId = paymentMethodConfigurationId,
                    requireCvcRecollection = true
                )
            )
        }
    }
}

Update parameters of the intent creation

To re-collect the CVC when confirming payment, include both the customerId and require_cvc_recollection parameters during the creation of the PaymentIntent.

main.rb
Ruby
Python
PHP
Node.js
Java
Go
.NET
No results
require 'stripe'
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/create-intent' do
  data = JSON.parse request.body.read
  params = {
    amount: 1099,
    currency: 'usd',
    # In the latest version of the API, specifying the `automatic_payment_methods` parameter is optional because Stripe enables its functionality by default.
    automatic_payment_methods: {enabled: true},
    customer: customer.id,
    payment_method_options: {
      card: {require_cvc_recollection: true}
    }
  }
  begin
    intent = Stripe::PaymentIntent.create(params)
    {client_secret: intent.client_secret}.to_json
  rescue Stripe::StripeError => e
    {error: e.error.message}.to_json
  end
end
Was this page helpful?
YesNo