Accepter les paiements dans l’application

Pour commencer, vous devez créer un compte Stripe. Inscrivez-vous maintenant.

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 :

# Available as a gem
sudo gem install stripe

# 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 :

plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

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

Vous devez également définir votre clé publiable afin que le SDK puisse effectuer des appels à l’API vers Stripe. Pour commencer rapidement, vous pouvez coder cela en dur côté client pendant l’intégration, mais récupérer la clé publiable sur votre serveur en mode 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")

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.

Nous proposons deux styles d’intégration.

PaymentSheet	PaymentSheet.FlowController
Affiche un formulaire permettant de collecter les informations de paiement et d’exécuter le paiement. Le libellé du bouton est Payer et le montant s’affiche. Un clic sur le bouton exécute le paiement.	Affiche un formulaire destiné à uniquement collecter les informations de paiement. Le libellé du bouton est Continuer. En cliquant dessus, le client est renvoyé vers votre application, où votre propre bouton exécute le paiement.

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

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

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

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

Sur votre serveur, créez a PaymentIntent en indiquant un montant et une devise. Vous pouvez gérer les moyens de paiement depuis le Dashboard. Stripe gère le l’affichage des moyens de paiement admissibles en fonction de facteurs tels que le montant de la transaction, la devise et le tunnel de paiement. Pour éviter que des clients malveillants ne choisissent eux-mêmes leurs tarifs, décidez toujours du montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

Si l’appel réussit, renvoyez la clé secrète du client du PaymentIntent. Si l’appel échoue, traitez l’erreur et renvoyez un message d’erreur avec une courte explication à l’intention de votre client.

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

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 :

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