Accéder directement au contenu
Créez un compte
 ou
connecter-vous
Logo de la documentation Stripe
/
Créez un compte
Connectez-vous

Accepter un paiement

Acceptez les paiements en ligne en toute sécurité.

Créez un formulaire de paiement ou utilisez une page de paiement préconfigurée pour commencer à accepter les paiements en ligne.

Intégrez l’interface utilisateur de paiement préconfigurée de Stripe au processus de paiement de votre application Android grâce à la classe PaymentSheet.

Configurer Stripe
Côté serveur
Côté client

Tout d’abord, il vous faut un compte Stripe. Inscrivez-vous.

Côté serveur

Cette intégration exige des endpoints sur votre serveur qui communiquent avec l’API Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur :

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'

Côté client

Le SDK Stripe Android est disponible en open source et fait l’objet d’une documentation complète.

Pour installer le SDK, ajoutez stripe-android au bloc dependencies de votre fichier app/build.gradle :

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")
}

Remarque

Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des versions sur GitHub. Pour savoir quand une nouvelle version est disponible, surveillez les versions du référentiel.

Activer les moyens de paiement

Affichez vos paramètres des moyens de paiement et activez les moyens de paiement que vous souhaitez prendre en charge. Vous devez activer au moins un moyen de paiement pour créer un PaymentIntent.

Par défaut, Stripe active les cartes bancaires et les autres moyens de paiement courants qui peuvent vous permettre d’atteindre davantage de clients. Nous vous recommandons toutefois d’activer d’autres moyens de paiement pertinents pour votre entreprise et vos clients. Consultez la page Prise en charge des moyens de paiement pour en savoir plus sur la prise en charge des produits et des moyens de paiement, et notre page des tarifs pour prendre connaissance des frais que nous appliquons.

Ajouter un endpoint
Côté serveur

Remarque

Pour afficher PaymentSheet avant de créer un PaymentIntent, consultez notre article Collecter les détails du paiement avant de créer un Intent.

Cette intégration utilise trois objets de l’API Stripe :

  1. PaymentIntent : pour représenter votre intention d’encaisser le paiement d’un client, Stripe utilise un objet PaymentIntent qui suit vos tentatives de débit et les changements d’état du paiement tout au long du processus.

  2. (Facultatif) Customer : pour configurer un moyen de paiement en vue de paiements futurs, vous devez l’associer à un objet Customer. Créez un objet Customer lorsque votre client ouvre un compte chez vous. Si votre client effectue un paiement en tant qu’invité, vous pouvez créer un objet Customer avant le paiement, puis l’associer ultérieurement à votre représentation interne du compte client.

  3. (Facultatif) Customer Ephemeral Key : l’objet Customer contient des informations sensibles qu’il n’est pas possible de récupérer directement depuis une application. Une clé éphémère permet d’accorder au SDK un accès temporaire à l’objet Customer.

Remarque

Si vous n’enregistrez jamais les cartes bancaires des clients et que vous n’autorisez pas vos clients réguliers à réutiliser les cartes enregistrées, vous pouvez exclure les objets Customer et Customer Ephemeral Key de votre intégration.

Pour des raisons de sécurité, votre application ne peut pas créer ces objets. À la place, ajoutez sur votre serveur un endpoint qui :

  1. Récupère l’objet Customer ou en crée un nouveau.
  2. Crée une clé éphémère pour le client.
  3. Crée un PaymentIntent comportant les paramètres amount, currency, customer. Vous pouvez également inclure le paramètre automatic_payment_methods (facultatif). Stripe l’active par défaut dans la dernière version de l’API.
  4. Renvoie la clé secrète du client du Payment Intent, le secret de la clé éphémère, l’id du client et votre clé publiable à votre application.

Les moyens de paiement présentés à votre client lors du processus de paiement sont également inclus dans le PaymentIntent. Vous pouvez laisser Stripe extraire (depuis les paramètres de votre Dashboard) les moyens de paiement à présenter, ou les répertorier manuellement. Quelle que soit l’option que vous choisissez, sachez que la devise transmise dans le PaymentIntent filtre les moyens de paiement présentés au client. Par exemple, si vous transmettez eur dans le PaymentIntent et que vous avez activé OXXO dans votre Dashboard, votre client ne verra pas ce moyen de paiement étant donné qu’OXXO ne prend pas en charge les paiements en eur.

À moins que votre intégration ne nécessite du code pour la présentation des moyens de paiement, Stripe vous recommande l’option automatisée. En effet, Stripe évalue la devise, les restrictions en matière de moyens de paiement ainsi que d’autres paramètres pour dresser la liste des moyens de paiement pris en charge. Ceux qui augmentent le taux de conversion et qui sont les plus pertinents pour la devise et le lieu de résidence du client sont priorisés.

Remarque

You can fork and deploy an implementation of this endpoint on CodeSandbox for testing.

Vous pouvez gérer les moyens de paiement depuis le Dashboard. Stripe gère le renvoi des moyens de paiement admissibles en fonction de facteurs tels que le montant de la transaction, la devise et le tunnel de paiement. Le PaymentIntent est créé à l’aide des moyens de paiement configurés dans le Dashboard. Si vous ne souhaitez pas utiliser le Dashboard ou souhaitez spécifier des moyens de paiement manuellement, vous pouvez les répertorier à l’aide de l’attribut payment_method_types.

Command Line
curl
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -X "POST"

# Create an Ephemeral Key for the Customer
curl https://api.stripe.com/v1/ephemeral_keys \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -H "Stripe-Version: 2025-08-27.basil" \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  # In the latest version of the API, specifying the `automatic_payment_methods` parameter
  # is optional because Stripe enables its functionality by default.
  -d "automatic_payment_methods[enabled]"=true \

Collecter les données de paiement
Côté client

Avant d’afficher le composant Element Payment pour mobile, vous devez, sur votre écran de paiement :

  • Présenter les produits commandés et le montant total des achats
  • Recueillez toutes les informations de livraison requises à l’aide du composant Address Element
  • Inclure un bouton de règlement pour afficher l’interface utilisateur de Stripe

Initialisez une instance PaymentSheet dans la méthode onCreate de votre classe CheckoutActivity, puis transmettez une méthode pour gérer le résultat.

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
}

Ensuite, récupérez la clé secrète du client du PaymentIntent, la clé secrète éphémère, l’ID du client et la clé publiable depuis l’endpoint que vous avez créé à l’étape précédente. Configurez la clé publiable à l’aide du paramètre PaymentConfiguration et utilisez les autres au moment d’afficher le 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(
          id = networkResult.customer,
          ephemeralKeySecret = networkResult.ephemeralKey
        )
        PaymentConfiguration.init(context, networkResult.publishableKey)
    }
  }
}

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

Lorsque le client appuie sur votre bouton de paiement, appelez presentWithPaymentIntent pour afficher le formulaire de paiement. Une fois que le client a effectué le paiement, le formulaire se ferme et le PaymentSheetResultCallback est appelé avec un 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

@OptIn(ExperimentalCustomerSessionApi::class)
@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(
          id = networkResult.customer,
          ephemeralKeySecret = networkResult.ephemeralKey
        )
        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")
    }
  }
}

Si vous définissez allowsDelayedPaymentMethods sur true, les moyens de paiement à notification différée, comme les comptes bancaires étasuniens, seront acceptés. Pour ces moyens de paiement, l’état final du paiement n’est pas connu une fois le processus du PaymentSheet achevé, et le paiement peut plus tard aboutir comme échouer. Si vous prenez en charge ces types de moyens de paiement, informez votre client que sa commande est confirmée et ne la traitez (en lui expédiant son produit, par exemple) qu’une fois le paiement reçu.

Gérer les événements post-paiement
Côté serveur

Stripe envoie un événement payment_intent.succeeded à l’issue du paiement. Utilisez l’outil de webhook du Dashboard ou suivez le guide consacré aux webhooks pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un flux de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. Côté client, il arrive en effet que l’utilisateur ferme la fenêtre de son navigateur ou quitte l’application avant l’exécution du rappel. Certains clients malintentionnés peuvent d’autre part tenter de manipuler la réponse. En configurant votre intégration de manière à ce qu’elle écoute les événements asynchrones, vous pourrez accepter plusieurs types de moyens de paiement avec une seule et même intégration.

En plus de l’événement payment_intent.succeeded, nous vous recommandons de gérer ces autres événements lorsque vous encaissez des paiements à l’aide de l’Element Payment :

ÉvénementDescriptionAction
payment_intent.succeededEnvoyé lorsqu’un client effectue un paiement avec succès.Envoyez au client une confirmation de commande et traitez sa commande.
payment_intent.processingEnvoyé lorsqu’un client initie un paiement, mais qu’il ne l’a pas encore finalisé. Dans la plupart des cas, cet événement est envoyé lorsque le client initie un prélèvement bancaire. Il est suivi par un événement payment_intent.succeeded ou payment_intent.payment_failed.Envoyez au client une confirmation de commande qui indique que son paiement est en attente. Pour des marchandises dématérialisées, vous pourrez traiter la commande sans attendre que le paiement soit effectué.
payment_intent.payment_failedEnvoyé lorsqu’un client effectue une tentative de paiement qui se solde par un échec.Si un paiement passe de l’état processing à payment_failed, proposez au client de retenter le paiement.

Tester l'intégration

Numéro de carteScénarioMéthode de test
Le paiement par carte bancaire aboutit et ne nécessite pas d’authentification.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte ainsi que la date d’expiration, le CVC et le code postal de votre choix.
Le paiement par carte bancaire requiert une authentification.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte ainsi que la date d’expiration, le CVC et le code postal de votre choix.
La carte est refusée avec un code de refus de type insufficient_funds.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte ainsi que la date d’expiration, le CVC et le code postal de votre choix.
La carte UnionPay a un numéro d’une longueur variable, allant de 13 à 19 chiffres.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte ainsi que la date d’expiration, le CVC et le code postal de votre choix.

Consultez la section consacrée aux tests pour obtenir des informations supplémentaires sur la manière de tester votre intégration.

FacultatifActiver Link

Activez Link dans vos paramètres des moyens de paiement pour permettre à vos clients d’enregistrer et de réutiliser en toute sécurité leurs informations de paiement à l’aide du bouton de paiement express en un clic de Link.

Transmettre l’adresse e-mail de votre client au composant Mobile Payment Element

Link authentifie un client à l’aide de son adresse e-mail. Stripe recommande de préremplir autant d’informations que possible afin de simplifier le processus de paiement.

Pour préremplir le nom, l’adresse e-mail et le numéro de téléphone du client, fournissez la propriété defaultBillingDetails avec vos informations client lors de l’initialisation de PaymentSheet.Configuration.

Kotlin
Java
No results
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Example, Inc.")
  .defaultBillingDetails(
    PaymentSheet.BillingDetails(
        name = "Jenny Rosen",
        email = "jenny.rosen@example.com",
        phone = "888-888-8888"
    )
  )
  .build()

FacultatifActiver Google Pay

Configurer votre intégration

Pour utiliser Google Pay, commencez par activer l’API Google Pay en ajoutant les informations suivantes au libellé <application> de votre AndroidManifest.xml :

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

Pour en savoir plus, consultez cette page indiquant comment configurer l’API Google Pay pour Android.

Ajouter Google Pay

Pour ajouter Google Pay à votre intégration, transmettez un PaymentSheet.GooglePayConfiguration avec votre environnement Google Pay (en mode production ou en mode test), ainsi que le code pays de votre entreprise lors de l’initialisation de 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()

Tester Google Pay

Google vous permet d’effectuer des paiements tests par le biais de sa suite de cartes de test. La suite de test prend en charge l’utilisation des cartes de test Stripe.

Vous pouvez tester Google Pay à l’aide d’un appareil Android physique. Assurez-vous d’avoir un appareil dans un pays où Google Pay est pris en charge et connectez-vous à un compte Google sur votre appareil de test avec une vraie carte enregistrée dans Google Wallet.

FacultatifActiver la numérisation de carte

Pour activer la prise en charge de la numérisation de carte, ajoutez stripecardscan au bloc dependencies de votre fichier app/build.gradle :

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

android { ... }

dependencies {
  // ...

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

FacultatifActiver les paiements ACH

Intégrez Financial Connections en tant que dépendance pour votre application afin d’activer les paiements par prélèvements ACH.

Le SDK Stripe Android est disponible en open source et fait l’objet d’une documentation complète.

Pour installer le SDK, ajoutez financial-connections au bloc dependencies de votre fichier app/build.gradle :

build.gradle.kts
Kotlin
Groovy
No results
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Financial Connections Android SDK
  implementation("com.stripe:financial-connections:21.26.1")
}

Remarque

Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des versions sur GitHub. Pour savoir quand une nouvelle version est disponible, surveillez les versions du référentiel.

FacultatifPersonnaliser la fiche

Pour personnaliser le formulaire de paiement, vous devez obligatoirement utiliser l’objet PaymentSheet.Configuration.

Appearance

Personnalisez les couleurs, les polices et même plus afin de vous adapter à l’apparence de votre application en utilisant l’API Appearance.

Mise en page des moyens de paiement

Configurez la mise en page des moyens de paiement dans la feuille à l’aide de paymentMethodLayout. Vous pouvez les afficher horizontalement, verticalement ou laisser Stripe optimiser la mise en page automatiquement.

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

Recueillir les adresses des utilisateurs

Recueillez les adresses de livraison ou de facturation de vos clients locaux et internationaux à l’aide du composant Address Element.

Nom d’affichage de l’entreprise

Spécifiez un nom d’entreprise à afficher pour le client en définissant merchantDisplayName. Par défaut, il s’agit du nom de votre application.

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

Mode sombre

Par défaut, PaymentSheet s’adapte automatiquement aux paramètres d’affichage du système de l’utilisateur (mode clair ou mode sombre). Vous pouvez modifier ce comportement en sélectionnant le mode clair ou le mode sombre sur votre application :

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

Informations de facturation par défaut

Si vous souhaitez définir des valeurs par défaut pour les informations de facturation collectées dans le formulaire de paiement, configurez la propriété defaultBillingDetails. Le PaymentSheet préremplit les champs avec les valeurs que vous fournissez.

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()

Configurer la collecte des données de facturation

Utiliser BillingDetailsCollectionConfiguration pour spécifier la manière dont vous souhaitez collecter les informations de facturation dans la PaymentSheet.

Vous pouvez collecter le nom, l’adresse e-mail, le numéro de téléphone et l’adresse de votre client.

Si vous souhaitez associer les informations de facturation par défaut à l’objet PaymentMethod même lorsque ces champs ne sont pas collectés dans l’interface utilisateur, définissez billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod sur 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()

Remarque

Consultez votre conseiller juridique au sujet des lois qui s’appliquent à la collecte d’informations. Ne collectez les numéros de téléphone que si vous en avez besoin pour la transaction.

FacultatifGérer la déconnexion de l'utilisateur

PaymentSheet enregistre certaines informations localement pour se souvenir si un utilisateur a utilisé Link au sein d’une application. Pour effacer l’état interne de PaymentSheet, appelez la méthode PaymentSheet.resetCustomer() lorsque votre utilisateur se déconnecte.

Kotlin
Java
No results
class MyActivity: Activity {

  fun onLogoutButtonClicked() {
    PaymentSheet.resetCustomer(this)
    // Other logout logic required by your app
  }
}

FacultatifMener à bien le paiement dans votre interface utilisateur

Vous pouvez présenter le formulaire de paiement pour collecter uniquement les informations du moyen de paiement et finaliser l’opération dans l’interface utilisateur de votre application. Cette méthode est utile si vous avez intégré un bouton d’achat personnalisé ou si vous avez besoin d’étapes supplémentaires après la collecte des informations de paiement.

Remarque

Un exemple d’intégration est disponible sur notre GitHub.

  1. Tout d’abord, initialisez PaymentSheet.FlowController au lieu de PaymentSheet en utilisant l’une des méthodes Builder.
Android (Kotlin)
Android (Java)
No results
class CheckoutActivity : AppCompatActivity() {
  private lateinit var flowController: PaymentSheet.FlowController

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

    flowController = PaymentSheet.FlowController.Builder(
      paymentResultCallback = ::onPaymentSheetResult,
      paymentOptionCallback = ::onPaymentOption,
    ).build(this)
  }
}
  1. Appelez ensuite configureWithPaymentIntent avec les clés d’objet Stripe récupérées depuis votre back-end et mettez à jour votre interface utilisateur dans le rappel en utilisant getPaymentOption(). Cette propriété contient une image et une étiquette représentant le moyen de paiement actuellement sélectionné par le client.
Android (Kotlin)
Android (Java)
No results
flowController.configureWithPaymentIntent(
  paymentIntentClientSecret = paymentIntentClientSecret,
  configuration = PaymentSheet.Configuration.Builder("Example, Inc.")
    .customer(PaymentSheet.CustomerConfiguration(
      id = customerId,
      ephemeralKeySecret = ephemeralKeySecret
    ))
    .build()
) { isReady, error ->
  if (isReady) {
    // Update your UI using `flowController.getPaymentOption()`
  } else {
    // handle FlowController configuration failure
  }
}
  1. Appelez ensuite presentPaymentOptions pour collecter les informations de paiement. Lorsque le client a terminé, le formulaire se ferme et appelle le paymentOptionCallback transmis plus tôt dans create. Implémentez cette méthode pour mettre à jour votre interface utilisateur avec la propriété paymentOption renvoyée.
Android (Kotlin)
Android (Java)
No results
// ...
  flowController.presentPaymentOptions()
// ...
  private fun onPaymentOption(paymentOption: PaymentOption?) {
    if (paymentOption != null) {
      paymentMethodButton.text = paymentOption.label
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        paymentOption.drawableResourceId,
        0,
        0,
        0
      )
    } else {
      paymentMethodButton.text = "Select"
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        null,
        null,
        null,
        null
      )
    }
  }
  1. Enfin, appelez confirm pour mener à bien le paiement. Lorsque le client a terminé, le formulaire se ferme et appelle le paymentResultCallback transmis plus tôt dans create.
Android (Kotlin)
Android (Java)
No results
// ...
    flowController.confirmPayment()
  // ...

  private fun onPaymentSheetResult(
    paymentSheetResult: PaymentSheetResult
  ) {
    when (paymentSheetResult) {
      is PaymentSheetResult.Canceled -> {
        // Payment canceled
      }
      is PaymentSheetResult.Failed -> {
        // Payment Failed. See logcat for details or inspect paymentSheetResult.error
      }
      is PaymentSheetResult.Completed -> {
        // Payment Complete
      }
    }
  }

Si vous définissez allowsDelayedPaymentMethods sur true, les moyens de paiement à notification différée, comme les comptes bancaires étasuniens, seront acceptés. Pour ces moyens de paiement, l’état final du paiement n’est pas connu une fois le processus du PaymentSheet achevé, et le paiement peut plus tard aboutir comme échouer. Si vous prenez en charge ces types de moyens de paiement, informez votre client que sa commande est confirmée et ne la traitez (en lui expédiant son produit, par exemple) qu’une fois le paiement reçu.

FacultatifActiver la collecte du CVC après confirmation

Les instructions suivantes pour récupérer le CVC d’une carte enregistrée pendant la confirmation du PaymentIntent supposent que votre intégration comprend les éléments suivants :

  • Création de PaymentIntents avant de collecter les informations de paiement

Mettre à jour les paramètres de création de l’Intent

Pour récupérer le CVC lors de la confirmation du paiement, ajoutez require_cvc_recollection lors de la création du PaymentIntent.

Command Line
curl
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -X "POST"

# Create an Ephemeral Key for the Customer
curl https://api.stripe.com/v1/ephemeral_keys \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -H "Stripe-Version: 2025-08-27.basil" \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "payment_method_options[card][require_cvc_recollection]"=true \
  # In the latest version of the API, specifying the `automatic_payment_methods` parameter
  # is optional because Stripe enables its functionality by default.
  -d "automatic_payment_methods[enabled]"=true \
Cette page vous a-t-elle été utile ?
OuiNon
Code quickstart
Guides connexes
Composants Apparence API
Autres scénarios de paiement
Fonctionnement des cartes bancaires